content
stringlengths 0
3.9M
| path
stringlengths 4
242
| contentHash
stringlengths 1
10
|
|---|---|---|
package org.jetbrains.haskell.psi
import com.intellij.lang.ASTNode
import com.intellij.extapi.psi.ASTWrapperPsiElement
import com.intellij.psi.PsiReference
import org.jetbrains.haskell.psi.reference.SomeIdReference
public class SomeId(node: ASTNode) : ASTWrapperPsiElement(node) {
override fun getReference(): PsiReference? {
return SomeIdReference(this)
}
} | plugin/src/org/jetbrains/haskell/psi/SomeId.kt | 1324156901 |
import org.junit.Test
import org.simpleflatmapper.jdbc.JdbcMapperFactory
import org.simpleflatmapper.util.TypeReference
import test.CsvLine
import java.sql.DriverManager
import kotlin.test.assertEquals
class JdbcCsvTest {
@Test
fun test() {
val connection = DriverManager.getConnection("jdbc:h2:mem:");
connection.use {
it.createStatement().use {
val rs = it.executeQuery("SELECT 1 as elt0,2 as elt1")
rs.use {
val pair = JdbcMapperFactory
.newInstance()
.newMapper(object : TypeReference<Pair<Int, Int>>() {})
.iterator(rs).next()
println(pair)
assertEquals(1, pair.first)
assertEquals(2, pair.second)
}
val rs2 = it.executeQuery("SELECT 1 as elt0,2 as elt1, 3 as elt2")
rs2.use {
val triple = JdbcMapperFactory
.newInstance()
.newMapper(object : TypeReference<Triple<Int, Int, Int>>() {})
.iterator(rs2).next()
println(triple)
assertEquals(1, triple.first)
assertEquals(2, triple.second)
assertEquals(3, triple.third)
}
}
}
}
@Test
fun test538() {
val connection = DriverManager.getConnection("jdbc:h2:mem:");
connection.use {
it.createStatement().use {
val rs = it.executeQuery("SELECT 1 as field1,2 as field2")
rs.use {
val item = JdbcMapperFactory
.newInstance()
.newMapper(CsvLine::class.java)
.iterator(rs).next()
println(item)
assertEquals("1", item.field1)
assertEquals("2", item.field2)
}
}
}
}
}
| sfm-test-kotlin/src/test/kotlin/test/JdbcCsvTest.kt | 4176533817 |
package ktx.app
import com.badlogic.gdx.Application.ApplicationType
import com.badlogic.gdx.Gdx
import com.badlogic.gdx.utils.GdxRuntimeException
import kotlin.contracts.ExperimentalContracts
import kotlin.contracts.InvocationKind
import kotlin.contracts.contract
/**
* Contains utilities for platform-specific code. Allows to easily determine current application platform
* and its version. Can execute given actions only on specific platforms.
*/
object Platform {
/**
* The [ApplicationType] reported by the current libGDX application. Throws [GdxRuntimeException] when unable to
* determine the platform.
*/
val currentPlatform: ApplicationType
get() = Gdx.app?.type ?: throw GdxRuntimeException("Gdx.app is not defined or is missing the application type.")
/**
* True if [ApplicationType.Applet] is the [currentPlatform].
*
* Deprecated. Since Applets are deprecated since Java 9 in 2017, developers are encouraged to use other technologies
* to target the web platforms such as the WebGL backend.
*/
@Deprecated(
message = "Java Applets are deprecated since Java 9 in 2017.",
replaceWith = ReplaceWith("isWeb")
)
val isApplet: Boolean
get() = currentPlatform === ApplicationType.Applet
/**
* True if [ApplicationType.Android] is the [currentPlatform].
*/
val isAndroid: Boolean
get() = currentPlatform === ApplicationType.Android
/**
* True if [ApplicationType.Desktop] with a graphical application is the [currentPlatform].
*/
val isDesktop: Boolean
get() = currentPlatform === ApplicationType.Desktop
/**
* True if [ApplicationType.HeadlessDesktop] without a graphical application is the [currentPlatform].
*/
val isHeadless: Boolean
get() = currentPlatform === ApplicationType.HeadlessDesktop
/**
* True if [ApplicationType.iOS] is the [currentPlatform].
*/
val isiOS: Boolean
get() = currentPlatform === ApplicationType.iOS
/**
* True if [ApplicationType.Android] or [ApplicationType.iOS] are the [currentPlatform].
*/
val isMobile: Boolean
get() = isAndroid || isiOS
/**
* True if [ApplicationType.WebGL] is the [currentPlatform]. To determine if the application is running in an Applet,
* use [isApplet] instead.
*/
val isWeb: Boolean
get() = currentPlatform == ApplicationType.WebGL
/**
* Android API version on Android, major OS version on iOS, 0 on most other platforms, or -1 if unable to read.
*/
val version: Int
get() = Gdx.app?.version ?: -1
/**
* Executes [action] if the [currentPlatform] is [ApplicationType.Applet]. Returns [action] result or null.
* @see isApplet
*/
@Deprecated(
message = "Java Applets are deprecated since Java 9 in 2017.",
replaceWith = ReplaceWith("runOnWeb")
)
@Suppress("DEPRECATION")
@OptIn(ExperimentalContracts::class)
inline fun <T> runOnApplet(action: () -> T?): T? {
contract { callsInPlace(action, InvocationKind.AT_MOST_ONCE) }
return if (isApplet) action() else null
}
/**
* Executes [action] if the [currentPlatform] is [ApplicationType.Android]. Returns [action] result or null.
* @see isAndroid
*/
@OptIn(ExperimentalContracts::class)
inline fun <T> runOnAndroid(action: () -> T?): T? {
contract { callsInPlace(action, InvocationKind.AT_MOST_ONCE) }
return if (isAndroid) action() else null
}
/**
* Executes [action] if the [currentPlatform] is [ApplicationType.Desktop]. Returns [action] result or null.
* @see isDesktop
*/
@OptIn(ExperimentalContracts::class)
inline fun <T> runOnDesktop(action: () -> T?): T? {
contract { callsInPlace(action, InvocationKind.AT_MOST_ONCE) }
return if (isDesktop) action() else null
}
/**
* Executes [action] if the [currentPlatform] is [ApplicationType.HeadlessDesktop]. Returns [action] result or null.
* @see isHeadless
*/
@OptIn(ExperimentalContracts::class)
inline fun <T> runOnHeadless(action: () -> T?): T? {
contract { callsInPlace(action, InvocationKind.AT_MOST_ONCE) }
return if (isHeadless) action() else null
}
/**
* Executes [action] if the [currentPlatform] is [ApplicationType.iOS]. Returns [action] result or null.
* @see isiOS
*/
@OptIn(ExperimentalContracts::class)
inline fun <T> runOniOS(action: () -> T?): T? {
contract { callsInPlace(action, InvocationKind.AT_MOST_ONCE) }
return if (isiOS) action() else null
}
/**
* Executes [action] if the [currentPlatform] is [ApplicationType.Android] or [ApplicationType.iOS].
* Returns [action] result or null.
* @see isMobile
*/
@OptIn(ExperimentalContracts::class)
inline fun <T> runOnMobile(action: () -> T?): T? {
contract { callsInPlace(action, InvocationKind.AT_MOST_ONCE) }
return if (isMobile) action() else null
}
/**
* Executes [action] if the [currentPlatform] is [ApplicationType.WebGL]. Returns [action] result or null.
* Not that the [action] will not be executed in an Applet - use [runOnApplet] instead.
* @see isWeb
*/
@OptIn(ExperimentalContracts::class)
inline fun <T> runOnWeb(action: () -> T?): T? {
contract { callsInPlace(action, InvocationKind.AT_MOST_ONCE) }
return if (isWeb) action() else null
}
/**
* Executes [action] is the current platform [version] (such as Android API version or iOS major OS version)
* is equal to or higher than [minVersion] and equal to or lower than [maxVersion]. If a [platform] is given,
* the [currentPlatform] must also be the same in order to execute the [action].
*
* All parameters are optional; if a parameter is not given, the associated condition does not have to be met
* to execute [action]. For example, if [minVersion] is given, but [maxVersion] is not, the current application
* [version] has to be the same as or above [minVersion], but there is no upper bound. Similarly, if a [platform]
* is not given, the [action] will be executed on any platform that meets the [version] criteria.
*
* Returns [action] result if it was executed or null otherwise.
*
* @see version
*/
@OptIn(ExperimentalContracts::class)
inline fun <T> runOnVersion(
minVersion: Int? = null,
maxVersion: Int? = null,
platform: ApplicationType? = null,
action: () -> T?
): T? {
contract { callsInPlace(action, InvocationKind.AT_MOST_ONCE) }
val matchesMinVersion = minVersion === null || minVersion <= version
val matchesMaxVersion = maxVersion === null || version <= maxVersion
val matchesPlatform = platform === null || currentPlatform === platform
return if (matchesMinVersion && matchesMaxVersion && matchesPlatform) action() else null
}
}
| app/src/main/kotlin/ktx/app/Platform.kt | 1394191819 |
package com.polidea.rxandroidble2.samplekotlin.example2_connection
import android.annotation.TargetApi
import android.content.Context
import android.content.Intent
import android.os.Build
import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import com.polidea.rxandroidble2.RxBleConnection
import com.polidea.rxandroidble2.RxBleDevice
import com.polidea.rxandroidble2.samplekotlin.R
import com.polidea.rxandroidble2.samplekotlin.SampleApplication
import com.polidea.rxandroidble2.samplekotlin.util.isConnected
import com.polidea.rxandroidble2.samplekotlin.util.showSnackbarShort
import io.reactivex.android.schedulers.AndroidSchedulers
import io.reactivex.disposables.CompositeDisposable
import io.reactivex.disposables.Disposable
import kotlinx.android.synthetic.main.activity_example2.autoconnect
import kotlinx.android.synthetic.main.activity_example2.connect_toggle
import kotlinx.android.synthetic.main.activity_example2.connection_state
import kotlinx.android.synthetic.main.activity_example2.newMtu
import kotlinx.android.synthetic.main.activity_example2.set_mtu
private const val EXTRA_MAC_ADDRESS = "extra_mac_address"
class ConnectionExampleActivity : AppCompatActivity() {
companion object {
fun newInstance(context: Context, macAddress: String) =
Intent(context, ConnectionExampleActivity::class.java).apply {
putExtra(EXTRA_MAC_ADDRESS, macAddress)
}
}
private lateinit var bleDevice: RxBleDevice
private var connectionDisposable: Disposable? = null
private var stateDisposable: Disposable? = null
private val mtuDisposable = CompositeDisposable()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_example2)
connect_toggle.setOnClickListener { onConnectToggleClick() }
set_mtu.setOnClickListener { onSetMtu() }
val macAddress = intent.getStringExtra(EXTRA_MAC_ADDRESS)
title = getString(R.string.mac_address, macAddress)
bleDevice = SampleApplication.rxBleClient.getBleDevice(macAddress!!)
// How to listen for connection state changes
// Note: it is meant for UI updates only — one should not observeConnectionStateChanges() with BLE connection logic
bleDevice.observeConnectionStateChanges()
.observeOn(AndroidSchedulers.mainThread())
.subscribe { onConnectionStateChange(it) }
.let { stateDisposable = it }
}
private fun onConnectToggleClick() {
if (bleDevice.isConnected) {
triggerDisconnect()
} else {
bleDevice.establishConnection(autoconnect.isChecked)
.observeOn(AndroidSchedulers.mainThread())
.doFinally { dispose() }
.subscribe({ onConnectionReceived() }, { onConnectionFailure(it) })
.let { connectionDisposable = it }
}
}
@TargetApi(21 /* Build.VERSION_CODES.LOLLIPOP */)
private fun onSetMtu() {
newMtu.text.toString().toIntOrNull()?.let { mtu ->
bleDevice.establishConnection(false)
.flatMapSingle { rxBleConnection -> rxBleConnection.requestMtu(mtu) }
.take(1) // Disconnect automatically after discovery
.observeOn(AndroidSchedulers.mainThread())
.doFinally { updateUI() }
.subscribe({ onMtuReceived(it) }, { onConnectionFailure(it) })
.let { mtuDisposable.add(it) }
}
}
private fun onConnectionFailure(throwable: Throwable) = showSnackbarShort("Connection error: $throwable")
private fun onConnectionReceived() = showSnackbarShort("Connection received")
private fun onConnectionStateChange(newState: RxBleConnection.RxBleConnectionState) {
connection_state.text = newState.toString()
updateUI()
}
private fun onMtuReceived(mtu: Int) = showSnackbarShort("MTU received: $mtu")
private fun dispose() {
connectionDisposable = null
updateUI()
}
private fun triggerDisconnect() = connectionDisposable?.dispose()
private fun updateUI() {
connect_toggle.setText(if (bleDevice.isConnected) R.string.button_disconnect else R.string.button_connect)
autoconnect.isEnabled = !bleDevice.isConnected
}
override fun onPause() {
super.onPause()
triggerDisconnect()
mtuDisposable.clear()
}
override fun onDestroy() {
super.onDestroy()
stateDisposable?.dispose()
}
}
| sample-kotlin/src/main/kotlin/com/polidea/rxandroidble2/samplekotlin/example2_connection/ConnectionExampleActivity.kt | 1559797764 |
package com.themovielist.moviedetail.review
import android.view.LayoutInflater
import android.view.ViewGroup
import com.themovielist.R
import com.themovielist.model.MovieReviewModel
import com.themovielist.ui.recyclerview.CustomRecyclerViewAdapter
class MovieReviewAdapter : CustomRecyclerViewAdapter<MovieReviewModel, MovieDetailReviewViewHolder> {
constructor(emptyMessageResId: Int, tryAgainClickListener: (() -> Unit)?) : super(emptyMessageResId, tryAgainClickListener)
constructor(tryAgainClickListener: (() -> Unit)?) : super(tryAgainClickListener)
override fun onCreateItemViewHolder(parent: ViewGroup, viewType: Int): MovieDetailReviewViewHolder {
val itemView = LayoutInflater.from(parent.context).inflate(R.layout.movie_review_item, parent, false)
return MovieDetailReviewViewHolder(itemView)
}
override fun onBindItemViewHolder(holder: MovieDetailReviewViewHolder, position: Int) {
val (author, content) = getItemByPosition(position)
holder.bind(author, content)
}
} | app/src/main/java/com/themovielist/moviedetail/review/MovieReviewAdapter.kt | 1086511341 |
package de.westnordost.streetcomplete.quests
import android.content.Context
import android.os.Bundle
import android.preference.PreferenceManager
import androidx.recyclerview.widget.GridLayoutManager
import android.view.View
import java.util.ArrayList
import java.util.LinkedList
import de.westnordost.streetcomplete.R
import de.westnordost.streetcomplete.view.ImageSelectAdapter
import de.westnordost.streetcomplete.view.Item
import kotlinx.android.synthetic.main.quest_generic_list.*
/**
* Abstract class for quests with a list of images and one or several to select.
*/
abstract class AImageListQuestAnswerFragment<I,T> : AbstractQuestFormAnswerFragment<T>() {
override val contentLayoutResId = R.layout.quest_generic_list
protected lateinit var imageSelector: ImageSelectAdapter<I>
private lateinit var favs: LastPickedValuesStore<I>
protected open val itemsPerRow = 4
/** return -1 for any number. Default: 1 */
protected open val maxSelectableItems = 1
/** return -1 for showing all items at once. Default: -1 */
protected open val maxNumberOfInitiallyShownItems = -1
protected abstract val items: List<Item<I>>
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
imageSelector = ImageSelectAdapter(maxSelectableItems)
}
override fun onAttach(ctx: Context) {
super.onAttach(ctx)
favs = LastPickedValuesStore(PreferenceManager.getDefaultSharedPreferences(ctx.applicationContext))
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
list.layoutManager = GridLayoutManager(activity, itemsPerRow)
list.isNestedScrollingEnabled = false
selectHintLabel.setText(if (maxSelectableItems == 1) R.string.quest_roofShape_select_one else R.string.quest_select_hint)
imageSelector.listeners.add(object : ImageSelectAdapter.OnItemSelectionListener {
override fun onIndexSelected(index: Int) {
checkIsFormComplete()
}
override fun onIndexDeselected(index: Int) {
checkIsFormComplete()
}
})
showMoreButton.setOnClickListener {
imageSelector.items = items.favouritesMovedToFront()
showMoreButton.visibility = View.GONE
}
var initiallyShow = maxNumberOfInitiallyShownItems
if (savedInstanceState != null) {
if (savedInstanceState.getBoolean(EXPANDED)) initiallyShow = -1
showItems(initiallyShow)
val selectedIndices = savedInstanceState.getIntegerArrayList(SELECTED_INDICES)!!
imageSelector.select(selectedIndices)
} else {
showItems(initiallyShow)
}
list.adapter = imageSelector
}
override fun onClickOk() {
val values = imageSelector.selectedItems
if (values.isNotEmpty()) {
favs.add(javaClass.simpleName, values)
onClickOk(values)
}
}
abstract protected fun onClickOk(selectedItems: List<I>)
override fun onSaveInstanceState(outState: Bundle) {
super.onSaveInstanceState(outState)
outState.putIntegerArrayList(SELECTED_INDICES, ArrayList(imageSelector.selectedIndices))
outState.putBoolean(EXPANDED, showMoreButton.visibility == View.GONE)
}
override fun isFormComplete() = imageSelector.selectedIndices.isNotEmpty()
private fun showItems(initiallyShow: Int) {
val allItems = items
val showAll = initiallyShow == -1 || initiallyShow >= allItems.size
showMoreButton.visibility = if(showAll) View.GONE else View.VISIBLE
val sortedItems = allItems.favouritesMovedToFront()
imageSelector.items = if(showAll) sortedItems else sortedItems.subList(0, initiallyShow)
}
private fun List<Item<I>>.favouritesMovedToFront(): List<Item<I>> {
val result: LinkedList<Item<I>> = LinkedList(this)
if (result.size > itemsPerRow) {
favs.moveLastPickedToFront(javaClass.simpleName, result, this)
}
return result
}
companion object {
private const val SELECTED_INDICES = "selected_indices"
private const val EXPANDED = "expanded"
}
}
| app/src/main/java/de/westnordost/streetcomplete/quests/AImageListQuestAnswerFragment.kt | 2529114594 |
/*
* Copyright (C) 2020 Reece H. Dunn
*
* 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 uk.co.reecedunn.intellij.plugin.xslt.psi.impl.xslt
import com.intellij.psi.PsiElement
import uk.co.reecedunn.intellij.plugin.xslt.ast.xslt.XsltEvaluate
import uk.co.reecedunn.intellij.plugin.xslt.psi.impl.XsltShadowPsiElement
class XsltEvaluatePsiImpl(element: PsiElement) : XsltShadowPsiElement(element), XsltEvaluate
| src/lang-xslt/main/uk/co/reecedunn/intellij/plugin/xslt/psi/impl/xslt/XsltEvaluatePsiImpl.kt | 741358000 |
package de.westnordost.streetcomplete.data.osm.osmquest
import de.westnordost.streetcomplete.data.osm.delete_element.DeleteOsmElementDao
import de.westnordost.streetcomplete.data.osm.mapdata.ElementKey
import de.westnordost.streetcomplete.data.osm.osmquest.undo.UndoOsmQuestDao
import de.westnordost.streetcomplete.data.osm.splitway.OsmQuestSplitWayDao
import javax.inject.Inject
/** Supplies a set of elements for which no quests should be created */
class BlacklistedElementsSource @Inject constructor(
private val splitWayDao: OsmQuestSplitWayDao,
private val deleteOsmElementDao: DeleteOsmElementDao,
private val undoOsmQuestDao: UndoOsmQuestDao
) {
fun getAll(): List<ElementKey> = (
splitWayDao.getAll() +
deleteOsmElementDao.getAll() +
undoOsmQuestDao.getAll()
).map { ElementKey(it.elementType, it.elementId) }
}
| app/src/main/java/de/westnordost/streetcomplete/data/osm/osmquest/BlacklistedElementsSource.kt | 31330381 |
/*
* Copyright (C) 2016-2017, 2020 Reece H. Dunn
*
* 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 uk.co.reecedunn.intellij.plugin.xquery.ast.update.facility
import com.intellij.psi.PsiElement
import uk.co.reecedunn.intellij.plugin.xpm.optree.expression.XpmExpression
/**
* An XQuery Update Facility 3.0 `TransformWithExpr` node in the XQuery AST.
*/
interface UpdateFacilityTransformWithExpr : PsiElement, XpmExpression
| src/lang-xquery/main/uk/co/reecedunn/intellij/plugin/xquery/ast/update/facility/UpdateFacilityTransformWithExpr.kt | 345750841 |
package org.stepik.android.view.latex.ui.widget
import android.content.Context
import android.graphics.Bitmap
import android.view.View
import android.webkit.WebView
import androidx.core.view.isVisible
import org.stepik.android.view.base.ui.extension.ExternalLinkWebViewClient
class ProgressableWebViewClient(
private val progressView: View,
private val webView: View,
context: Context = progressView.context
) : ExternalLinkWebViewClient(context) {
override fun onPageStarted(view: WebView?, url: String?, favicon: Bitmap?) {
super.onPageStarted(view, url, favicon)
progressView.isVisible = true
webView.isVisible = false
}
override fun onPageFinished(view: WebView?, url: String?) {
progressView.isVisible = false
webView.isVisible = true
super.onPageFinished(view, url)
}
} | app/src/main/java/org/stepik/android/view/latex/ui/widget/ProgressableWebViewClient.kt | 3046110868 |
package org.granchi.hollywood
import kotlin.reflect.KClass
/**
* A Model that only contains several submodels.
*
* Their order can be important, because actions will be applied to every subModel following the
* same order.
*
* It serves as a way to decompose business logic in several components.
*/
data class CompositeModel(var models: List<Model>) : Model() {
constructor(vararg model: Model) : this(listOf(* model))
init {
if (models.isEmpty()) {
throw IllegalArgumentException()
} else {
models = models.distinct()
}
}
override fun actUpon(action: Action): Model? {
val resultModels = models
.map {
it.actUpon(action)
}
.filterNotNull()
.flatMap {
(it as? CompositeModel)?.models ?: listOf(it)
}
.distinct()
return if (resultModels.isEmpty()) {
null
} else {
CompositeModel(resultModels)
}
}
@Suppress("UNCHECKED_CAST")
override fun <T : Model> getSubmodelsOfType(type: KClass<out T>): Collection<T> {
return if (type.isInstance(this)) {
listOf(this as T)
} else {
models
.flatMap { it.getSubmodelsOfType(type) }
.distinct()
}
}
}
| core/src/main/kotlin/org/granchi/hollywood/CompositeModel.kt | 2928407527 |
package tv.fanart.config.model
data class ConfigFile(
val updates: UpdateConfig?
) | src/main/kotlin/tv/fanart/config/model/ConfigFile.kt | 4173587556 |
package com.michalfaber.drawertemplate.views.adapters
import android.support.v7.widget.RecyclerView
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import kotlin.reflect.KClass
/**
Provides specific implementation of view holder based on registered class
Holds a map where key is a ViewHolder hashCode and value is a pair: layout id and function
which creates specific implementation of ViewHolder.
*/
class ViewHolderProvider {
private val viewHolderFactories = hashMapOf<Int, Pair<Int, Any>>()
[suppress("UNCHECKED_CAST")]
fun provideViewHolder(viewGroup: ViewGroup, viewType: Int): RecyclerView.ViewHolder {
val value = viewHolderFactories.get(viewType)
if (value == null) {
throw RuntimeException("Not found ViewHolder factory for viewType:$viewType")
}
// get the layout id and factory function
val (layoutId: Int, f: Any) = value
val viewHolderFactory = f as (View) -> RecyclerView.ViewHolder
// inflate a view based on the layout ud
val view = LayoutInflater.from(viewGroup.getContext()).inflate(layoutId, viewGroup, false)
// create specific view holder
return viewHolderFactory(view)
}
fun registerViewHolderFactory<T>(key: KClass<T>, layoutId: Int, viewHolderFactory: (View) -> T) {
viewHolderFactories.put(key.hashCode(), Pair(layoutId, viewHolderFactory))
}
} | app/src/main/kotlin/views/adapters/ViewHolderProvider.kt | 3796492925 |
package com.dss.sdatabase.model
/**
* Created by gustavo.vieira on 04/05/2015.
*/
class BDCreate {
var fieldName: String? = ""
var fieldType: String? = ""
constructor(fieldName: String, fieldType: String) {
this.fieldName = fieldName
this.fieldType = fieldType
}
constructor()
}
| library/src/main/java/com/dss/sdatabase/model/BDCreate.kt | 3580295369 |
package eu.kanade.tachiyomi.data.track.anilist
import eu.kanade.domain.track.service.TrackPreferences
import eu.kanade.tachiyomi.data.database.models.Track
import eu.kanade.tachiyomi.data.track.TrackManager
import eu.kanade.tachiyomi.data.track.model.TrackSearch
import uy.kohesive.injekt.injectLazy
import java.text.SimpleDateFormat
import java.util.Locale
data class ALManga(
val media_id: Long,
val title_user_pref: String,
val image_url_lge: String,
val description: String?,
val format: String,
val publishing_status: String,
val start_date_fuzzy: Long,
val total_chapters: Int,
) {
fun toTrack() = TrackSearch.create(TrackManager.ANILIST).apply {
media_id = [email protected]_id
title = title_user_pref
total_chapters = [email protected]_chapters
cover_url = image_url_lge
summary = description ?: ""
tracking_url = AnilistApi.mangaUrl(media_id)
publishing_status = [email protected]_status
publishing_type = format
if (start_date_fuzzy != 0L) {
start_date = try {
val outputDf = SimpleDateFormat("yyyy-MM-dd", Locale.US)
outputDf.format(start_date_fuzzy)
} catch (e: Exception) {
""
}
}
}
}
data class ALUserManga(
val library_id: Long,
val list_status: String,
val score_raw: Int,
val chapters_read: Int,
val start_date_fuzzy: Long,
val completed_date_fuzzy: Long,
val manga: ALManga,
) {
fun toTrack() = Track.create(TrackManager.ANILIST).apply {
media_id = manga.media_id
title = manga.title_user_pref
status = toTrackStatus()
score = score_raw.toFloat()
started_reading_date = start_date_fuzzy
finished_reading_date = completed_date_fuzzy
last_chapter_read = chapters_read.toFloat()
library_id = [email protected]_id
total_chapters = manga.total_chapters
}
fun toTrackStatus() = when (list_status) {
"CURRENT" -> Anilist.READING
"COMPLETED" -> Anilist.COMPLETED
"PAUSED" -> Anilist.ON_HOLD
"DROPPED" -> Anilist.DROPPED
"PLANNING" -> Anilist.PLAN_TO_READ
"REPEATING" -> Anilist.REREADING
else -> throw NotImplementedError("Unknown status: $list_status")
}
}
fun Track.toAnilistStatus() = when (status) {
Anilist.READING -> "CURRENT"
Anilist.COMPLETED -> "COMPLETED"
Anilist.ON_HOLD -> "PAUSED"
Anilist.DROPPED -> "DROPPED"
Anilist.PLAN_TO_READ -> "PLANNING"
Anilist.REREADING -> "REPEATING"
else -> throw NotImplementedError("Unknown status: $status")
}
private val preferences: TrackPreferences by injectLazy()
fun Track.toAnilistScore(): String = when (preferences.anilistScoreType().get()) {
// 10 point
"POINT_10" -> (score.toInt() / 10).toString()
// 100 point
"POINT_100" -> score.toInt().toString()
// 5 stars
"POINT_5" -> when {
score == 0f -> "0"
score < 30 -> "1"
score < 50 -> "2"
score < 70 -> "3"
score < 90 -> "4"
else -> "5"
}
// Smiley
"POINT_3" -> when {
score == 0f -> "0"
score <= 35 -> ":("
score <= 60 -> ":|"
else -> ":)"
}
// 10 point decimal
"POINT_10_DECIMAL" -> (score / 10).toString()
else -> throw NotImplementedError("Unknown score type")
}
| app/src/main/java/eu/kanade/tachiyomi/data/track/anilist/AnilistModels.kt | 307690093 |
package info.nightscout.androidaps.plugins.pump.danaR.comm
import info.nightscout.androidaps.danar.comm.MsgSetSingleBasalProfile
import org.junit.Assert
import org.junit.Test
class MsgSetSingleBasalProfileTest : DanaRTestBase() {
@Test fun runTest() {
val packet = MsgSetSingleBasalProfile(injector, createArray(24, 2.0))
// test message decoding
packet.handleMessage(createArray(34, 7.toByte()))
Assert.assertEquals(true, packet.failed)
}
} | danar/src/test/java/info/nightscout/androidaps/plugins/pump/danaR/comm/MsgSetSingleBasalProfileTest.kt | 1278088903 |
package info.nightscout.androidaps.plugins.pump.omnipod.common.ui.wizard.activation.fragment.info
import android.os.Bundle
import android.view.View
import android.widget.Button
import androidx.annotation.IdRes
import androidx.appcompat.app.AlertDialog
import androidx.fragment.app.viewModels
import androidx.lifecycle.ViewModelProvider
import androidx.navigation.fragment.findNavController
import info.nightscout.androidaps.plugins.pump.omnipod.common.R
import info.nightscout.androidaps.plugins.pump.omnipod.common.di.OmnipodPluginQualifier
import info.nightscout.androidaps.plugins.pump.omnipod.common.ui.wizard.activation.viewmodel.info.AttachPodViewModel
import info.nightscout.androidaps.plugins.pump.omnipod.common.ui.wizard.common.fragment.InfoFragmentBase
import javax.inject.Inject
class AttachPodFragment : InfoFragmentBase() {
@Inject
@OmnipodPluginQualifier
lateinit var viewModelFactory: ViewModelProvider.Factory
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
val vm: AttachPodViewModel by viewModels { viewModelFactory }
this.viewModel = vm
}
@IdRes
override fun getNextPageActionId(): Int = R.id.action_attachPodFragment_to_insertCannulaFragment
override fun getIndex(): Int = 3
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
view.findViewById<Button>(R.id.button_next).setOnClickListener {
context?.let {
AlertDialog.Builder(it, R.style.DialogTheme)
.setIcon(android.R.drawable.ic_dialog_alert)
.setTitle(getString(getTitleId()))
.setMessage(getString(R.string.omnipod_common_pod_activation_wizard_attach_pod_confirm_insert_cannula_text))
.setPositiveButton(getString(R.string.omnipod_common_ok)) { _, _ ->
findNavController().navigate(
getNextPageActionId()
)
}
.setNegativeButton(getString(R.string.omnipod_common_cancel), null)
.show()
}
}
}
} | omnipod-common/src/main/java/info/nightscout/androidaps/plugins/pump/omnipod/common/ui/wizard/activation/fragment/info/AttachPodFragment.kt | 2268442212 |
package info.nightscout.androidaps
import info.nightscout.shared.logging.AAPSLoggerTest
import info.nightscout.androidaps.utils.rx.AapsSchedulers
import info.nightscout.androidaps.utils.rx.TestAapsSchedulers
import org.junit.Before
import org.junit.Rule
import org.mockito.Mockito
import org.mockito.junit.MockitoJUnit
import org.mockito.junit.MockitoRule
import java.util.*
@Suppress("SpellCheckingInspection")
open class TestBase {
val aapsLogger = AAPSLoggerTest()
val aapsSchedulers: AapsSchedulers = TestAapsSchedulers()
// Add a JUnit rule that will setup the @Mock annotated vars and log.
// Another possibility would be to add `MockitoAnnotations.initMocks(this) to the setup method.
@get:Rule
val mockitoRule: MockitoRule = MockitoJUnit.rule()
@Before
fun setupLocale() {
Locale.setDefault(Locale.ENGLISH)
System.setProperty("disableFirebase", "true")
}
// Workaround for Kotlin nullability.
// https://medium.com/@elye.project/befriending-kotlin-and-mockito-1c2e7b0ef791
// https://stackoverflow.com/questions/30305217/is-it-possible-to-use-mockito-in-kotlin
fun <T> anyObject(): T {
Mockito.any<T>()
return uninitialized()
}
@Suppress("Unchecked_Cast")
fun <T> uninitialized(): T = null as T
} | danars/src/test/java/info/nightscout/androidaps/TestBase.kt | 3491534278 |
/*
* Copyright 2020 Square Inc.
*
* 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.squareup.wire
actual class GrpcClient {
actual fun <S : Any, R : Any> newCall(method: GrpcMethod<S, R>): GrpcCall<S, R> {
throw UnsupportedOperationException("wire-grpc-client doesn't support JS yet.")
}
actual fun <S : Any, R : Any> newStreamingCall(
method: GrpcMethod<S, R>
): GrpcStreamingCall<S, R> {
throw UnsupportedOperationException("wire-grpc-client doesn't support JS yet.")
}
}
| wire-library/wire-grpc-client/src/jsMain/kotlin/com/squareup/wire/GrpcClient.kt | 174935184 |
// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
package com.intellij.devkit.workspaceModel
import com.intellij.codeInspection.LocalInspectionTool
import com.intellij.codeInspection.LocalQuickFixOnPsiElement
import com.intellij.codeInspection.ProblemsHolder
import com.intellij.openapi.diagnostic.logger
import com.intellij.openapi.project.Project
import com.intellij.openapi.roots.ProjectRootManager
import com.intellij.psi.PsiElement
import com.intellij.psi.PsiFile
import com.intellij.psi.search.GlobalSearchScope
import com.intellij.workspaceModel.storage.CodeGeneratorVersions
import org.jetbrains.kotlin.KtNodeTypes
import org.jetbrains.kotlin.idea.stubindex.KotlinClassShortNameIndex
import org.jetbrains.kotlin.parsing.parseNumericLiteral
import org.jetbrains.kotlin.psi.*
private val LOG = logger<WorkspaceImplObsoleteInspection>()
class WorkspaceImplObsoleteInspection: LocalInspectionTool() {
override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean) = object : KtVisitorVoid() {
override fun visitClass(klass: KtClass) {
if (!klass.isWorkspaceEntity()) return
val targetApiVersion = calculateTargetApiVersion(klass.project)
if (targetApiVersion == null) {
LOG.info("Can't evaluate target API version")
return
}
if (klass.name == "Builder") return
val foundImplClasses = KotlinClassShortNameIndex.get("${klass.name}Impl", klass.project, GlobalSearchScope.allScope(klass.project))
if (foundImplClasses.isEmpty()) return
val implClass = foundImplClasses.first()
val apiVersion = (implClass as? KtClass)?.getApiVersion()
if (apiVersion == targetApiVersion) return
holder.registerProblem(klass.nameIdentifier!!, DevKitWorkspaceModelBundle.message("inspection.workspace.msg.obsolete.implementation"),
RegenerateWorkspaceModelFix(klass.nameIdentifier!!))
}
}
private fun calculateTargetApiVersion(project: Project): Int? {
val generatorVersions = CodeGeneratorVersions::class.simpleName
val foundClasses = KotlinClassShortNameIndex.get(generatorVersions!!, project, GlobalSearchScope.allScope(project))
if (foundClasses.isEmpty()) {
error("Can't find $generatorVersions")
}
val ktClassOrObject = foundClasses.first()
val fieldName = "API_VERSION"
val ktDeclaration = ktClassOrObject.declarations.first { it.name == fieldName }
if (ktDeclaration !is KtProperty) {
error("Unexpected declaration type for field $fieldName")
}
val propertyExpression = ktDeclaration.initializer as? KtConstantExpression
if (propertyExpression == null) {
error("Property value should be int constant")
}
val elementType = propertyExpression.node.elementType
if (elementType == KtNodeTypes.INTEGER_CONSTANT) {
return parseNumericLiteral(propertyExpression.text, elementType)?.toInt()
}
return null
}
}
private class RegenerateWorkspaceModelFix(psiElement: PsiElement) : LocalQuickFixOnPsiElement(psiElement) {
override fun getText() = DevKitWorkspaceModelBundle.message("inspection.workspace.msg.regenerate.implementation")
override fun getFamilyName() = name
override fun invoke(project: Project, file: PsiFile, startElement: PsiElement, endElement: PsiElement) {
val projectFileIndex = ProjectRootManager.getInstance(project).fileIndex
val module = projectFileIndex.getModuleForFile(file.virtualFile)
WorkspaceModelGenerator.generate(project, module!!)
}
} | plugins/devkit/intellij.devkit.workspaceModel/src/WorkspaceImplObsoleteInspection.kt | 3052762490 |
// 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.compilerPlugin.samWithReceiver
import com.intellij.openapi.module.Module
import com.intellij.openapi.project.Project
import com.intellij.openapi.roots.ProjectRootModificationTracker
import com.intellij.psi.util.CachedValueProvider.Result
import com.intellij.psi.util.CachedValuesManager
import com.intellij.util.containers.ContainerUtil
import org.jetbrains.kotlin.analyzer.ModuleInfo
import org.jetbrains.kotlin.container.StorageComponentContainer
import org.jetbrains.kotlin.container.useInstance
import org.jetbrains.kotlin.descriptors.ModuleDescriptor
import org.jetbrains.kotlin.extensions.StorageComponentContainerContributor
import org.jetbrains.kotlin.idea.base.scripting.projectStructure.ScriptDependenciesInfo
import org.jetbrains.kotlin.idea.base.scripting.projectStructure.ScriptModuleInfo
import org.jetbrains.kotlin.idea.base.projectStructure.moduleInfo.ModuleProductionSourceInfo
import org.jetbrains.kotlin.idea.compilerPlugin.getSpecialAnnotations
import org.jetbrains.kotlin.platform.TargetPlatform
import org.jetbrains.kotlin.platform.jvm.isJvm
import org.jetbrains.kotlin.samWithReceiver.SamWithReceiverCommandLineProcessor.Companion.ANNOTATION_OPTION
import org.jetbrains.kotlin.samWithReceiver.SamWithReceiverCommandLineProcessor.Companion.PLUGIN_ID
import org.jetbrains.kotlin.samWithReceiver.SamWithReceiverResolverExtension
class IdeSamWithReceiverComponentContributor(val project: Project) : StorageComponentContainerContributor {
private companion object {
val ANNOTATION_OPTION_PREFIX = "plugin:$PLUGIN_ID:${ANNOTATION_OPTION.optionName}="
}
private val cache = CachedValuesManager.getManager(project).createCachedValue({
Result.create(
ContainerUtil.createConcurrentWeakMap<Module, List<String>>(),
ProjectRootModificationTracker.getInstance(
project
)
)
}, /* trackValue = */ false)
private fun getAnnotationsForModule(module: Module): List<String> {
return cache.value.getOrPut(module) { module.getSpecialAnnotations(ANNOTATION_OPTION_PREFIX) }
}
override fun registerModuleComponents(
container: StorageComponentContainer,
platform: TargetPlatform,
moduleDescriptor: ModuleDescriptor
) {
if (!platform.isJvm()) return
val annotations =
when (val moduleInfo = moduleDescriptor.getCapability(ModuleInfo.Capability)) {
is ScriptModuleInfo -> moduleInfo.scriptDefinition.annotationsForSamWithReceivers
is ScriptDependenciesInfo.ForFile -> moduleInfo.scriptDefinition.annotationsForSamWithReceivers
is ModuleProductionSourceInfo -> getAnnotationsForModule(moduleInfo.module)
else -> null
} ?: return
container.useInstance(SamWithReceiverResolverExtension(annotations))
}
} | plugins/kotlin/compiler-plugins/sam-with-receiver/common/src/org/jetbrains/kotlin/idea/compilerPlugin/samWithReceiver/IdeSamWithReceiverComponentContributor.kt | 3916396815 |
context(A) <caret>private fun x() = Unit | plugins/kotlin/idea/tests/testData/editor/enterHandler/contextReceivers/topLevelFunctionWithContextReceiver.kt | 603646747 |
package me.elsiff.morefish.fishing
import me.elsiff.morefish.fishing.competition.FishingCompetition
import org.bukkit.entity.Item
import org.bukkit.entity.Player
/**
* Created by elsiff on 2019-01-09.
*/
interface FishTypeTable : Map<FishRarity, Set<FishType>> {
val defaultRarity: FishRarity?
val rarities: Set<FishRarity>
val types: Set<FishType>
fun pickRandomRarity(): FishRarity
fun pickRandomType(rarity: FishRarity = pickRandomRarity()): FishType
fun pickRandomType(
caught: Item,
fisher: Player,
competition: FishingCompetition,
rarity: FishRarity = pickRandomRarity()
): FishType
} | src/main/kotlin/me/elsiff/morefish/fishing/FishTypeTable.kt | 3152036611 |
/*
* Copyright 2003-2022 The IdeaVim authors
*
* Use of this source code is governed by an MIT-style
* license that can be found in the LICENSE.txt file or at
* https://opensource.org/licenses/MIT.
*/
package com.maddyhome.idea.vim.vimscript.services
import com.maddyhome.idea.vim.api.injector
import com.maddyhome.idea.vim.diagnostic.vimLogger
import org.jetbrains.annotations.NonNls
import java.io.File
import java.io.IOException
import java.nio.file.Paths
object VimRcService {
private val logger = vimLogger<VimRcService>()
@NonNls
const val VIMRC_FILE_NAME = "ideavimrc"
@NonNls
private val HOME_VIMRC_PATHS = arrayOf(".$VIMRC_FILE_NAME", "_$VIMRC_FILE_NAME")
@NonNls
private val XDG_VIMRC_PATH = "ideavim" + File.separator + VIMRC_FILE_NAME
@JvmStatic
fun findIdeaVimRc(): File? {
val homeDirName = System.getProperty("user.home")
// Check whether file exists in home dir
if (homeDirName != null) {
for (fileName in HOME_VIMRC_PATHS) {
val file = File(homeDirName, fileName)
if (file.exists()) {
return file
}
}
}
// Check in XDG config directory
val xdgConfigHomeProperty = System.getenv("XDG_CONFIG_HOME")
val xdgConfig = if (xdgConfigHomeProperty == null || xdgConfigHomeProperty == "") {
if (homeDirName != null) Paths.get(homeDirName, ".config", XDG_VIMRC_PATH).toFile() else null
} else {
File(xdgConfigHomeProperty, XDG_VIMRC_PATH)
}
return if (xdgConfig != null && xdgConfig.exists()) xdgConfig else null
}
private val newIdeaVimRcTemplate = """
"" Source your .vimrc
"source ~/.vimrc
"" -- Suggested options --
" Show a few lines of context around the cursor. Note that this makes the
" text scroll if you mouse-click near the start or end of the window.
set scrolloff=5
" Do incremental searching.
set incsearch
" Don't use Ex mode, use Q for formatting.
map Q gq
"" -- Map IDE actions to IdeaVim -- https://jb.gg/abva4t
"" Map \r to the Reformat Code action
"map \r <Action>(ReformatCode)
"" Map <leader>d to start debug
"map <leader>d <Action>(Debug)
"" Map \b to toggle the breakpoint on the current line
"map \b <Action>(ToggleLineBreakpoint)
" Find more examples here: https://jb.gg/share-ideavimrc
""".trimIndent()
fun findOrCreateIdeaVimRc(): File? {
val found = findIdeaVimRc()
if (found != null) return found
val homeDirName = System.getProperty("user.home")
if (homeDirName != null) {
for (fileName in HOME_VIMRC_PATHS) {
try {
val file = File(homeDirName, fileName)
file.createNewFile()
file.writeText(newIdeaVimRcTemplate)
injector.vimrcFileState.filePath = file.absolutePath
return file
} catch (ignored: IOException) {
// Try to create one of two files
}
}
}
return null
}
@JvmStatic
fun executeIdeaVimRc() {
try {
injector.vimscriptExecutor.executingVimscript = true
val ideaVimRc = findIdeaVimRc()
if (ideaVimRc != null) {
logger.info("Execute ideavimrc file: " + ideaVimRc.absolutePath)
injector.vimscriptExecutor.executeFile(ideaVimRc)
injector.vimrcFileState.saveFileState(ideaVimRc.absolutePath)
} else {
logger.info("ideavimrc file isn't found")
}
} finally {
injector.vimscriptExecutor.executingVimscript = false
}
}
}
| vim-engine/src/main/kotlin/com/maddyhome/idea/vim/vimscript/services/VimRcService.kt | 1973758455 |
/* Copyright 2016-present The KotlinNLP Authors. All Rights Reserved.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, you can obtain one at http://mozilla.org/MPL/2.0/.
* ------------------------------------------------------------------*/
package com.kotlinnlp.simplednn.core.arrays
import com.kotlinnlp.simplednn.core.layers.helpers.RelevanceUtils
import com.kotlinnlp.simplednn.simplemath.ndarray.NDArray
import com.kotlinnlp.simplednn.simplemath.ndarray.dense.DenseNDArray
/**
* Get the errors of the input of the unit. The errors of the output must be already set.
*
* @param w the weights
*
* @return the errors of the input of this unit
*/
fun AugmentedArray<DenseNDArray>.getInputErrors(w: NDArray<*>): DenseNDArray = this.errors.t.dot(w)
/**
* Get the relevance of the input of the unit. The relevance of the output must be already set.
*
* @param x the input of the unit
* @param cw the weights-contribution of the input to calculate the output
*
* @return the relevance of the input of the unit
*/
fun AugmentedArray<DenseNDArray>.getInputRelevance(x: DenseNDArray, cw: DenseNDArray): DenseNDArray =
RelevanceUtils.calculateRelevanceOfArray(
x = x,
y = this.valuesNotActivated,
yRelevance = this.relevance,
contributions = cw
)
| src/main/kotlin/com/kotlinnlp/simplednn/core/arrays/AugmentedArrayExtensions.kt | 103522373 |
package org.wordpress.android.ui.posts.prepublishing.visibility.usecases
import org.wordpress.android.fluxc.model.PostImmutableModel
import org.wordpress.android.fluxc.model.PostModel
import org.wordpress.android.fluxc.model.post.PostStatus
import org.wordpress.android.ui.posts.EditPostRepository
import org.wordpress.android.ui.posts.EditPostRepository.UpdatePostResult
import org.wordpress.android.ui.posts.PostUtilsWrapper
import org.wordpress.android.util.DateTimeUtilsWrapper
import javax.inject.Inject
class UpdatePostStatusUseCase @Inject constructor(
private val dateTimeUtilsWrapper: DateTimeUtilsWrapper,
private val postUtilsWrapper: PostUtilsWrapper
) {
fun updatePostStatus(
postStatus: PostStatus,
editPostRepository: EditPostRepository,
onPostStatusUpdated: (PostImmutableModel) -> Unit
) {
editPostRepository.updateAsync({ postModel: PostModel ->
// we set the date to immediately if it's scheduled.
if (postStatus == PostStatus.PRIVATE) {
if (postUtilsWrapper.isPublishDateInTheFuture(postModel.dateCreated))
postModel.setDateCreated(dateTimeUtilsWrapper.currentTimeInIso8601())
}
postModel.setStatus(postStatus.toString())
true
}, { postModel, result ->
if (result == UpdatePostResult.Updated) {
onPostStatusUpdated.invoke(postModel)
}
})
}
}
| WordPress/src/main/java/org/wordpress/android/ui/posts/prepublishing/visibility/usecases/UpdatePostStatusUseCase.kt | 1458150193 |
/* Copyright 2016-present The KotlinNLP Authors. All Rights Reserved.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, you can obtain one at http://mozilla.org/MPL/2.0/.
* ------------------------------------------------------------------*/
package com.kotlinnlp.simplednn.core.layers.models.feedforward.batchnorm
import com.kotlinnlp.simplednn.core.arrays.AugmentedArray
import com.kotlinnlp.simplednn.core.layers.Layer
import com.kotlinnlp.simplednn.core.layers.LayerType
import com.kotlinnlp.simplednn.core.layers.helpers.RelevanceHelper
import com.kotlinnlp.simplednn.simplemath.ndarray.NDArray
import com.kotlinnlp.simplednn.simplemath.ndarray.Shape
import com.kotlinnlp.simplednn.simplemath.ndarray.dense.DenseNDArray
import com.kotlinnlp.simplednn.simplemath.ndarray.dense.DenseNDArrayFactory
/**
* The batch normalization layer structure.
*
* @property inputArrays the input arrays of the layer
* @property inputType the type of the input arrays
* @property params the parameters which connect the input to the output
*/
internal class BatchNormLayer<InputNDArrayType : NDArray<InputNDArrayType>>(
val inputArrays: List<AugmentedArray<InputNDArrayType>>,
inputType: LayerType.Input,
override val params: BatchNormLayerParameters
) : Layer<InputNDArrayType>(
inputArray = AugmentedArray(params.inputSize), // empty array (it should not be used)
inputType = inputType,
outputArray = AugmentedArray(1),
params = params,
activationFunction = null,
dropout = 0.0
) {
/**
* The size of the input arrays.
*/
val inputSize: Int = this.inputArrays.first().values.length
/**
* The list containing the layer output.
*/
val outputArrays: List<AugmentedArray<DenseNDArray>> = List(this.inputArrays.size) {
AugmentedArray(DenseNDArrayFactory.zeros(Shape(this.inputSize)))
}
/**
* Support vector for the mean of the input arrays.
*/
internal val mean: DenseNDArray = DenseNDArrayFactory.zeros(Shape(this.inputSize))
/**
* Support vector for the standard deviation of the input arrays.
*/
internal val stdDev: DenseNDArray = DenseNDArrayFactory.zeros(Shape(this.inputSize))
/**
* The helper which executes the forward.
*/
override val forwardHelper = BatchNormForwardHelper(layer = this)
/**
* The helper which executes the backward.
*/
override val backwardHelper = BatchNormBackwardHelper(layer = this)
/**
* The helper which calculates the relevance.
*/
override val relevanceHelper: RelevanceHelper? = null
/**
* Check the size of the input arrays.
*/
init {
require(this.inputArrays.all { it.size == this.inputSize }) {
"All the input arrays must have the same size."
}
}
/**
* Set the values of the input arrays.
*
* @param inputs the values of the input arrays
*/
fun setInputs(inputs: List<InputNDArrayType>) {
this.inputArrays.zip(inputs).forEach { (array, values) ->
array.assignValues(values)
}
}
/**
* Set the errors of the output arrays.
*
* @param outputErrors the errors of each output array
*/
fun setErrors(outputErrors: List<DenseNDArray>) {
this.outputArrays.zip(outputErrors).forEach { (array, error) ->
array.assignErrors(error)
}
}
/**
* @param copy whether the returned errors must be a copy or a reference
*
* @return the errors of the input arrays
*/
fun getInputErrors(copy: Boolean = true): List<DenseNDArray> = this.inputArrays.map {
if (copy) it.errors.copy() else it.errors
}
}
| src/main/kotlin/com/kotlinnlp/simplednn/core/layers/models/feedforward/batchnorm/BatchNormLayer.kt | 2129162607 |
/*
* Copyright 2016 Nicolas Picon <[email protected]>
*
* 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 fr.nicopico.happybirthday.ui.home
import android.Manifest.permission.READ_CONTACTS
import android.os.Bundle
import android.support.v7.widget.LinearLayoutManager
import android.view.Menu
import android.view.MenuItem
import android.view.View
import fr.nicopico.happybirthday.R
import fr.nicopico.happybirthday.data.repository.ContactRepository
import fr.nicopico.happybirthday.domain.model.Contact
import fr.nicopico.happybirthday.domain.model.nextBirthdaySorter
import fr.nicopico.happybirthday.extensions.ensurePermissions
import fr.nicopico.happybirthday.extensions.ifElse
import fr.nicopico.happybirthday.extensions.toast
import fr.nicopico.happybirthday.inject.AppComponent
import fr.nicopico.happybirthday.ui.BaseActivity
import kotlinx.android.synthetic.main.activity_main.*
import rx.Observable
import rx.Subscriber
import rx.Subscription
import rx.android.schedulers.AndroidSchedulers
import timber.log.Timber
import java.util.concurrent.TimeUnit
import javax.inject.Inject
class MainActivity : BaseActivity() {
@Inject
lateinit var contactRepository: ContactRepository
lateinit private var contactAdapter: ContactAdapter
private var subscription: Subscription? = null
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
contactAdapter = ContactAdapter(this)
rvContacts.apply {
layoutManager = LinearLayoutManager(this@MainActivity)
adapter = contactAdapter
}
loadContacts()
}
override fun onDestroy() {
subscription?.unsubscribe()
super.onDestroy()
}
override fun onCreateOptionsMenu(menu: Menu): Boolean {
menuInflater.inflate(R.menu.main, menu)
return super.onCreateOptionsMenu(menu)
}
override fun onOptionsItemSelected(item: MenuItem): Boolean {
if (item.itemId == R.id.menu_reload) {
loadContacts(delay = true)
return true
}
else {
return super.onOptionsItemSelected(item)
}
}
override fun inject(component: AppComponent) {
component.inject(this)
}
private fun loadContacts(delay: Boolean = false) {
subscription?.unsubscribe()
val contactObservable: Observable<List<Contact>> = ensurePermissions(READ_CONTACTS) {
contactRepository
.list(sorter = nextBirthdaySorter())
.ifElse(delay, ifTrue = {
delay(1, TimeUnit.SECONDS)
})
.observeOn(AndroidSchedulers.mainThread())
.doOnSubscribe { progressBar.visibility = View.VISIBLE }
}
subscription = contactObservable.subscribe(subscriber)
}
private val subscriber = object : Subscriber<List<Contact>>() {
override fun onNext(contacts: List<Contact>?) {
progressBar.visibility = View.GONE
contactAdapter.data = contacts
}
override fun onCompleted() {
// No-op
}
override fun onError(e: Throwable?) {
progressBar.visibility = View.GONE
toast("Error $e")
Timber.e(e, "Unable to retrieve contact")
}
}
}
| app/src/main/java/fr/nicopico/happybirthday/ui/home/MainActivity.kt | 4102246249 |
/*
* Copyright 2000-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.debugger
import org.jetbrains.concurrency.Promise
import org.jetbrains.concurrency.then
import org.jetbrains.concurrency.thenAsyncAccept
import org.jetbrains.debugger.values.Value
import org.jetbrains.io.JsonUtil
import java.util.*
import java.util.regex.Pattern
private val KEY_NOTATION_PROPERTY_NAME_PATTERN = Pattern.compile("[\\p{L}_$]+[\\d\\p{L}_$]*")
object ValueModifierUtil {
fun setValue(variable: Variable,
newValue: String,
evaluateContext: EvaluateContext,
modifier: ValueModifier) = evaluateContext.evaluate(newValue)
.thenAsyncAccept { modifier.setValue(variable, it.value, evaluateContext) }
fun evaluateGet(variable: Variable,
host: Any,
evaluateContext: EvaluateContext,
selfName: String): Promise<Value> {
val builder = StringBuilder(selfName)
appendUnquotedName(builder, variable.name)
return evaluateContext.evaluate(builder.toString(), Collections.singletonMap(selfName, host), false)
.then {
variable.value = it.value
it.value
}
}
fun propertyNamesToString(list: List<String>, quotedAware: Boolean): String {
val builder = StringBuilder()
for (i in list.indices.reversed()) {
val name = list[i]
doAppendName(builder, name, quotedAware && (name[0] == '"' || name[0] == '\''))
}
return builder.toString()
}
fun appendUnquotedName(builder: StringBuilder, name: String) {
doAppendName(builder, name, false)
}
}
private fun doAppendName(builder: StringBuilder, name: String, quoted: Boolean) {
val useKeyNotation = !quoted && KEY_NOTATION_PROPERTY_NAME_PATTERN.matcher(name).matches()
if (builder.length != 0) {
builder.append(if (useKeyNotation) '.' else '[')
}
if (useKeyNotation) {
builder.append(name)
}
else {
if (quoted) {
builder.append(name)
}
else {
JsonUtil.escape(name, builder)
}
builder.append(']')
}
} | platform/script-debugger/backend/src/org/jetbrains/debugger/ValueModifierUtil.kt | 2049848879 |
// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
package org.jetbrains.plugins.gradle.testFramework.fixtures.impl
import com.intellij.openapi.Disposable
import com.intellij.openapi.externalSystem.importing.ImportSpecBuilder
import com.intellij.openapi.externalSystem.model.task.ExternalSystemTaskId
import com.intellij.openapi.externalSystem.model.task.ExternalSystemTaskNotificationListenerAdapter
import com.intellij.openapi.externalSystem.model.task.ExternalSystemTaskType
import com.intellij.openapi.externalSystem.service.notification.ExternalSystemProgressNotificationManager
import com.intellij.openapi.externalSystem.util.ExternalSystemUtil
import com.intellij.openapi.externalSystem.util.refreshAndWait
import com.intellij.openapi.module.Module
import com.intellij.openapi.observable.operations.CompoundParallelOperationTrace
import com.intellij.openapi.observable.operations.ObservableOperationTrace
import com.intellij.openapi.project.Project
import com.intellij.openapi.project.modules
import com.intellij.openapi.util.Disposer
import com.intellij.openapi.vfs.VirtualFile
import com.intellij.testFramework.PlatformTestUtil
import com.intellij.testFramework.closeProjectAsync
import com.intellij.testFramework.common.runAll
import com.intellij.testFramework.fixtures.SdkTestFixture
import com.intellij.testFramework.openProjectAsync
import com.intellij.testFramework.runInEdtAndWait
import kotlinx.coroutines.runBlocking
import org.gradle.util.GradleVersion
import org.jetbrains.concurrency.AsyncPromise
import org.jetbrains.plugins.gradle.testFramework.fixtures.FileTestFixture
import org.jetbrains.plugins.gradle.testFramework.fixtures.GradleTestFixture
import org.jetbrains.plugins.gradle.testFramework.fixtures.GradleTestFixtureFactory
import org.jetbrains.plugins.gradle.testFramework.util.generateWrapper
import org.jetbrains.plugins.gradle.testFramework.util.openProjectAsyncAndWait
import org.jetbrains.plugins.gradle.testFramework.util.withSuppressedErrors
import org.jetbrains.plugins.gradle.util.GradleConstants
import org.jetbrains.plugins.gradle.util.waitForProjectReload
import java.util.concurrent.TimeUnit
internal class GradleTestFixtureImpl private constructor(
override val projectName: String,
override val gradleVersion: GradleVersion,
private val sdkFixture: SdkTestFixture,
override val fileFixture: FileTestFixture
) : GradleTestFixture {
private lateinit var _project: Project
private lateinit var testDisposable: Disposable
private val projectOperations = CompoundParallelOperationTrace<Any>()
override val project: Project get() = _project
override val module: Module get() = project.modules.single { it.name == project.name }
constructor(
projectName: String,
gradleVersion: GradleVersion,
configureProject: FileTestFixture.Builder.() -> Unit
) : this(
projectName, gradleVersion,
GradleTestFixtureFactory.getFixtureFactory().createGradleJvmTestFixture(gradleVersion),
GradleTestFixtureFactory.getFixtureFactory().createFileTestFixture("GradleTestFixture/$gradleVersion/$projectName") {
configureProject()
withFiles { generateWrapper(it, gradleVersion) }
withFiles { runBlocking { createProjectCaches(it) } }
}
)
override fun setUp() {
testDisposable = Disposer.newDisposable()
sdkFixture.setUp()
fileFixture.setUp()
installTaskExecutionWatcher()
installProjectReloadWatcher()
_project = runBlocking { openProjectAsync(fileFixture.root) }
}
override fun tearDown() {
runAll(
{ fileFixture.root.refreshAndWait() },
{ projectOperations.waitForOperation() },
{ if (_project.isInitialized) runBlocking { _project.closeProjectAsync() } },
{ Disposer.dispose(testDisposable) },
{ fileFixture.tearDown() },
{ sdkFixture.tearDown() }
)
}
private fun installTaskExecutionWatcher() {
val listener = object : ExternalSystemTaskNotificationListenerAdapter() {
override fun onStart(id: ExternalSystemTaskId, workingDir: String?) {
projectOperations.startTask(id)
}
override fun onEnd(id: ExternalSystemTaskId) {
projectOperations.finishTask(id)
}
}
val progressManager = ExternalSystemProgressNotificationManager.getInstance()
progressManager.addNotificationListener(listener, testDisposable)
}
private fun installProjectReloadWatcher() {
val reloadListener = object : ExternalSystemTaskNotificationListenerAdapter() {
override fun onStart(id: ExternalSystemTaskId, workingDir: String?) {
if (workingDir == fileFixture.root.path) {
if (id.type == ExternalSystemTaskType.RESOLVE_PROJECT) {
fileFixture.addIllegalOperationError("Unexpected project reload: $workingDir")
}
}
}
}
val progressManager = ExternalSystemProgressNotificationManager.getInstance()
progressManager.addNotificationListener(reloadListener, testDisposable)
}
override fun reloadProject() {
if (fileFixture.isModified()) {
fileFixture.addIllegalOperationError("Unexpected reload with modified project files")
}
fileFixture.withSuppressedErrors {
waitForProjectReload {
ExternalSystemUtil.refreshProject(
fileFixture.root.path,
ImportSpecBuilder(project, GradleConstants.SYSTEM_ID)
)
}
fileFixture.root.refreshAndWait()
}
}
companion object {
fun ObservableOperationTrace.waitForOperation() {
val promise = AsyncPromise<Nothing?>()
afterOperation { promise.setResult(null) }
if (isOperationCompleted()) {
promise.setResult(null)
}
runInEdtAndWait {
PlatformTestUtil.waitForPromise<Nothing?>(promise, TimeUnit.MINUTES.toMillis(1))
}
}
private suspend fun createProjectCaches(projectRoot: VirtualFile) {
val project = openProjectAsyncAndWait(projectRoot)
try {
projectRoot.refreshAndWait()
}
finally {
project.closeProjectAsync(save = true)
}
}
}
}
| plugins/gradle/testSources/org/jetbrains/plugins/gradle/testFramework/fixtures/impl/GradleTestFixtureImpl.kt | 581386737 |
/*******************************************************************************
* Copyright 2000-2022 JetBrains s.r.o. and contributors.
*
* 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.jetbrains.packagesearch.intellij.plugin.extensibility
import com.intellij.buildsystem.model.DeclaredDependency
import com.intellij.buildsystem.model.OperationFailure
import com.intellij.buildsystem.model.OperationItem
import com.intellij.buildsystem.model.unified.UnifiedDependency
import com.intellij.buildsystem.model.unified.UnifiedDependencyRepository
import com.intellij.openapi.extensions.ExtensionPointName
import com.intellij.openapi.project.Project
import com.intellij.psi.PsiFile
import com.jetbrains.packagesearch.intellij.plugin.intentions.PackageSearchDependencyUpgradeQuickFix
import com.jetbrains.packagesearch.intellij.plugin.util.asCoroutine
/**
* Extension point that allows to modify the dependencies of a specific project.
*/
@Deprecated(
"Use async version. Either AsyncProjectModuleOperationProvider or CoroutineProjectModuleOperationProvider." +
" Remember to change the extension point type in the xml",
ReplaceWith(
"ProjectAsyncModuleOperationProvider",
"com.jetbrains.packagesearch.intellij.plugin.extensibility.ProjectAsyncModuleOperationProvider"
),
DeprecationLevel.WARNING
)
interface ProjectModuleOperationProvider {
companion object {
private val extensionPointName
get() = ExtensionPointName.create<ProjectModuleOperationProvider>("com.intellij.packagesearch.projectModuleOperationProvider")
internal val extensions
get() = extensionPointName.extensions.map { it.asCoroutine() }
}
/**
* Returns whether the implementation of the interface uses the shared "packages update available"
* inspection and quickfix. This is `false` by default; override this property and return `true`
* to opt in to [PackageUpdateInspection].
*
* @return `true` opt in to [PackageUpdateInspection], false otherwise.
* @see PackageUpdateInspection
* @see PackageSearchDependencyUpgradeQuickFix
*/
fun usesSharedPackageUpdateInspection(): Boolean = false
/**
* Checks if current implementation has support in the given [project] for the current [psiFile].
* @return `true` if the [project] and [psiFile] are supported.
*/
fun hasSupportFor(project: Project, psiFile: PsiFile?): Boolean
/**
* Checks if current implementation has support in the given [projectModuleType].
* @return `true` if the [projectModuleType] is supported.
*/
fun hasSupportFor(projectModuleType: ProjectModuleType): Boolean
/**
* Adds a dependency to the given [module] using [operationMetadata].
* @return A list containing all failures encountered during the operation. If the list is empty, the operation was successful.
*/
fun addDependencyToModule(
operationMetadata: DependencyOperationMetadata,
module: ProjectModule
): Collection<OperationFailure<out OperationItem>> = emptyList()
/**
* Removes a dependency from the given [module] using [operationMetadata].
* @return A list containing all failures encountered during the operation. If the list is empty, the operation was successful.
*/
fun removeDependencyFromModule(
operationMetadata: DependencyOperationMetadata,
module: ProjectModule
): Collection<OperationFailure<out OperationItem>> = emptyList()
/**
* Modify a dependency in the given [module] using [operationMetadata].
* @return A list containing all failures encountered during the operation. If the list is empty, the operation was successful.
*/
fun updateDependencyInModule(
operationMetadata: DependencyOperationMetadata,
module: ProjectModule
): Collection<OperationFailure<out OperationItem>> = emptyList()
/**
* Lists all dependencies declared in the given [module]. A declared dependency
* have to be explicitly written in the build file.
* @return A [Collection]<[UnifiedDependency]> found in the project.
*/
fun declaredDependenciesInModule(
module: ProjectModule
): Collection<DeclaredDependency> = emptyList()
/**
* Lists all resolved dependencies in the given [module].
* @return A [Collection]<[UnifiedDependency]> found in the project.
*/
fun resolvedDependenciesInModule(
module: ProjectModule,
scopes: Set<String> = emptySet()
): Collection<UnifiedDependency> = emptyList()
/**
* Adds the [repository] to the given [module].
* @return A list containing all failures encountered during the operation. If the list is empty, the operation was successful.
*/
fun addRepositoryToModule(
repository: UnifiedDependencyRepository,
module: ProjectModule
): Collection<OperationFailure<out OperationItem>> = emptyList()
/**
* Removes the [repository] from the given [module].
* @return A list containing all failures encountered during the operation. If the list is empty, the operation was successful.
*/
fun removeRepositoryFromModule(
repository: UnifiedDependencyRepository,
module: ProjectModule
): Collection<OperationFailure<out OperationItem>> = emptyList()
/**
* Lists all repositories in the given [module].
* @return A [Collection]<[UnifiedDependencyRepository]> found the project.
*/
fun listRepositoriesInModule(
module: ProjectModule
): Collection<UnifiedDependencyRepository> = emptyList()
}
| plugins/package-search/src/com/jetbrains/packagesearch/intellij/plugin/extensibility/ProjectModuleOperationProvider.kt | 564884950 |
// PROBLEM: Redundant lambda arrow
// WITH_STDLIB
fun f(cbs: List<(Boolean) -> Unit>) {
cbs[0](true)
}
fun main() {
f(listOf({ <caret>_ -> println("hello") }))
} | plugins/kotlin/idea/tests/testData/inspectionsLocal/redundantLambdaArrow/typeParameter3.kt | 2450232538 |
package com.austinv11.d4j.bot.command.impl
import com.austinv11.d4j.bot.CLIENT
import com.austinv11.d4j.bot.command.*
import com.austinv11.d4j.bot.db.Tag
import com.austinv11.d4j.bot.db.TagTable
import com.austinv11.d4j.bot.extensions.embed
import com.austinv11.d4j.bot.extensions.formattedName
import com.austinv11.d4j.bot.extensions.isBotOwner
class TagCommand : CommandExecutor() {
override val name: String = "tag"
override val aliases: Array<String> = arrayOf("tags")
@Executor("Gets a list of tags.")
fun execute() = context.embed.apply {
withTitle("Available tags:")
withDesc(buildString {
TagTable.tags.forEachIndexed { i, tag ->
appendln("${i+1}. ${tag.name}")
}
})
}
@Executor("Gets a specific tag.")
fun execute(@Parameter("The tag to get.") tag: String) = context.embed.apply {
val tag = TagTable.getTag(tag)
if (tag == null) {
throw CommandException("Tag not found!")
} else {
withTitle(tag.name)
withDesc(tag.content)
val user = CLIENT.getUserByID(tag.author)
if (user != null) {
withAuthorIcon(user.avatarURL)
withAuthorName(user.formattedName(context.guild))
withTimestamp(tag.timestamp)
}
}
}
@Executor("Performs a an action on the tag list.")
fun execute(@Parameter("The action to perform.") action: OneArgActions,
@Parameter("The tag to perform the action on.") tag: String): Any {
when (action) {
OneArgActions.REMOVE -> {
val currTag = TagTable.getTag(tag)
if (currTag != null) {
if (!!context.author.isBotOwner && context.author.longID != currTag.author)
throw CommandException("You can't modify another user's tag!")
}
TagTable.removeTag(tag)
return true
}
OneArgActions.GET -> {
return@execute execute(tag)
}
}
}
@Executor("Sets a tag's content.")
fun execute(@Parameter("The action to perform.") action: TwoArgActions,
@Parameter("The tag to perform the action on.") tag: String,
@Parameter("The content to associate with the tag.") content: String): Boolean {
when (action) {
TwoArgActions.PUT -> {
val currTag = TagTable.getTag(tag)
if (currTag != null) {
if (!!context.author.isBotOwner && context.author.longID != currTag.author)
throw CommandException("You can't modify another user's tag!")
}
TagTable.addTag(Tag(tag, context.author.longID, content, System.currentTimeMillis()))
}
}
return true
}
enum class OneArgActions {
REMOVE, GET
}
enum class TwoArgActions {
PUT
}
}
| src/main/kotlin/com/austinv11/d4j/bot/command/impl/TagCommand.kt | 2054910777 |
package com.eden.orchid.search.components
import com.eden.orchid.api.options.annotations.Description
import com.eden.orchid.api.options.annotations.Option
import com.eden.orchid.api.options.annotations.StringDefault
import com.eden.orchid.api.theme.assets.AssetManagerDelegate
import com.eden.orchid.api.theme.components.OrchidComponent
@Description(
"Add Algolia Docsearch to your site with minimal configuration.",
name = "Algolia DocSearch"
)
class AlgoliaDocSearchComponent : OrchidComponent("algoliaDocsearch", true) {
@Option
@Description("The API key for your site. Your apiKey will be given to you once Algolia creates your config.")
lateinit var apiKey: String
@Option
@Description("The API key for your site. Your indexName will be given to you once Algolia creates your config.")
lateinit var indexName: String
@Option
@Description("The selector for your search input field.")
@StringDefault("form[data-orchid-search] input[name=query]")
lateinit var selector: String
@Option
@Description("Set debug to true if you want to inspect the dropdown.")
var debug: Boolean = false
override fun loadAssets(delegate: AssetManagerDelegate): Unit = with(delegate) {
addCss("https://cdn.jsdelivr.net/npm/docsearch.js@2/dist/cdn/docsearch.min.css")
addJs("https://cdn.jsdelivr.net/npm/docsearch.js@2/dist/cdn/docsearch.min.js")
addJs("assets/js/algoliaDocsearch.js") { inlined = true }
}
override fun isHidden(): Boolean {
return true
}
}
| plugins/OrchidSearch/src/main/kotlin/com/eden/orchid/search/components/AlgoliaDocSearchComponent.kt | 934495827 |
package com.daveme.chocolateCakePHP.view
import com.daveme.chocolateCakePHP.Settings
import com.daveme.chocolateCakePHP.isCakeViewFile
import com.daveme.chocolateCakePHP.viewType
import com.intellij.openapi.project.Project
import com.intellij.psi.PsiElement
import com.jetbrains.php.lang.psi.elements.PhpNamedElement
import com.jetbrains.php.lang.psi.elements.Variable
import com.jetbrains.php.lang.psi.resolve.types.PhpType
import com.jetbrains.php.lang.psi.resolve.types.PhpTypeProvider4
class ThisVariableInViewTypeProvider : PhpTypeProvider4 {
override fun getKey(): Char {
return '\u8313'
}
override fun complete(p0: String?, p1: Project?): PhpType? = null
override fun getType(psiElement: PsiElement): PhpType? {
if (psiElement !is Variable) {
return null
}
val settings = Settings.getInstance(psiElement.project)
if (!settings.enabled) {
return null
}
if (!psiElement.textMatches("\$this")) {
return null
}
if (!isCakeViewFile(settings, psiElement.containingFile)) {
return null
}
return viewType(settings)
}
override fun getBySignature(
expression: String,
set: Set<String>,
i: Int,
project: Project
): Collection<PhpNamedElement> {
// We use the default signature processor exclusively:
return emptyList()
}
}
| src/main/kotlin/com/daveme/chocolateCakePHP/view/ThisVariableInViewTypeProvider.kt | 978681686 |
// Copyright 2000-2021 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.
package com.jetbrains.python.sdk
import com.google.gson.Gson
import com.google.gson.annotations.SerializedName
import com.intellij.execution.ExecutionException
import com.intellij.execution.target.TargetEnvironment
import com.intellij.execution.target.TargetEnvironment.TargetPath
import com.intellij.execution.target.TargetEnvironmentRequest
import com.intellij.execution.target.TargetProgressIndicatorAdapter
import com.intellij.execution.target.value.getRelativeTargetPath
import com.intellij.execution.target.value.getTargetDownloadPath
import com.intellij.execution.target.value.getTargetUploadPath
import com.intellij.openapi.Disposable
import com.intellij.openapi.diagnostic.logger
import com.intellij.openapi.progress.ProgressIndicator
import com.intellij.openapi.project.Project
import com.intellij.openapi.project.modules
import com.intellij.openapi.project.rootManager
import com.intellij.openapi.projectRoots.Sdk
import com.intellij.openapi.util.Disposer
import com.intellij.openapi.vfs.LocalFileSystem
import com.intellij.remote.RemoteSdkProperties
import com.intellij.util.PathMappingSettings
import com.intellij.util.PathUtil
import com.intellij.util.io.ZipUtil
import com.intellij.util.io.deleteWithParentsIfEmpty
import com.jetbrains.python.PythonHelper
import com.jetbrains.python.run.*
import com.jetbrains.python.run.target.HelpersAwareTargetEnvironmentRequest
import com.jetbrains.python.target.PyTargetAwareAdditionalData
import com.jetbrains.python.target.PyTargetAwareAdditionalData.Companion.pathsAddedByUser
import com.jetbrains.python.target.PyTargetAwareAdditionalData.Companion.pathsRemovedByUser
import java.nio.file.Files
import java.nio.file.attribute.FileTime
import java.time.Instant
import kotlin.io.path.deleteExisting
import kotlin.io.path.div
private const val STATE_FILE = ".state.json"
class PyTargetsRemoteSourcesRefresher(val sdk: Sdk, private val project: Project) {
private val pyRequest: HelpersAwareTargetEnvironmentRequest =
checkNotNull(PythonInterpreterTargetEnvironmentFactory.findPythonTargetInterpreter(sdk, project))
private val targetEnvRequest: TargetEnvironmentRequest
get() = pyRequest.targetEnvironmentRequest
init {
assert(sdk !is Disposable || !Disposer.isDisposed(sdk))
}
@Throws(ExecutionException::class)
fun run(indicator: ProgressIndicator) {
val localRemoteSourcesRoot = Files.createDirectories(sdk.remoteSourcesLocalPath)
val localUploadDir = Files.createTempDirectory("remote_sync")
val uploadVolume = TargetEnvironment.UploadRoot(localRootPath = localUploadDir, targetRootPath = TargetPath.Temporary())
targetEnvRequest.uploadVolumes += uploadVolume
val downloadVolume = TargetEnvironment.DownloadRoot(localRootPath = localRemoteSourcesRoot, targetRootPath = TargetPath.Temporary())
targetEnvRequest.downloadVolumes += downloadVolume
pyRequest.targetEnvironmentRequest.ensureProjectSdkAndModuleDirsAreOnTarget(project)
val execution = prepareHelperScriptExecution(helperPackage = PythonHelper.REMOTE_SYNC, helpersAwareTargetRequest = pyRequest)
val stateFilePath = localRemoteSourcesRoot / STATE_FILE
val stateFilePrevTimestamp: FileTime
if (Files.exists(stateFilePath)) {
stateFilePrevTimestamp = Files.getLastModifiedTime(stateFilePath)
Files.copy(stateFilePath, localUploadDir / STATE_FILE)
execution.addParameter("--state-file")
execution.addParameter(uploadVolume.getTargetUploadPath().getRelativeTargetPath(STATE_FILE))
}
else {
stateFilePrevTimestamp = FileTime.from(Instant.MIN)
}
execution.addParameter(downloadVolume.getTargetDownloadPath())
val targetWithVfs = sdk.targetEnvConfiguration?.let { PythonInterpreterTargetEnvironmentFactory.getTargetWithMappedLocalVfs(it) }
if (targetWithVfs != null) {
// If sdk is target that supports local VFS, there is no reason to copy editable packages to remote_sources
// since their paths should be available locally (to be edited)
// Such packages are in user content roots, so we report them to remote_sync script
val moduleRoots = project.modules.flatMap { it.rootManager.contentRoots.asList() }.mapNotNull {
targetWithVfs.getTargetPathFromVfs(it)
}
if (moduleRoots.isNotEmpty()) {
execution.addParameter("--project-roots")
for (root in moduleRoots) {
execution.addParameter(root)
}
}
}
val targetIndicator = TargetProgressIndicatorAdapter(indicator)
val environment = targetEnvRequest.prepareEnvironment(targetIndicator)
try {
// XXX Make it automatic
environment.uploadVolumes.values.forEach { it.upload(".", targetIndicator) }
val cmd = execution.buildTargetedCommandLine(environment, sdk, emptyList())
cmd.execute(environment, indicator)
// XXX Make it automatic
environment.downloadVolumes.values.forEach { it.download(".", indicator) }
}
finally {
environment.shutdown()
}
if (!Files.exists(stateFilePath)) {
throw IllegalStateException("$stateFilePath is missing")
}
if (Files.getLastModifiedTime(stateFilePath) <= stateFilePrevTimestamp) {
throw IllegalStateException("$stateFilePath has not been updated")
}
val stateFile: StateFile
Files.newBufferedReader(stateFilePath).use {
stateFile = Gson().fromJson(it, StateFile::class.java)
}
val pathMappings = PathMappingSettings()
// Preserve mappings for paths added by user and explicitly excluded by user
// We may lose these mappings otherwise
(sdk.sdkAdditionalData as? PyTargetAwareAdditionalData)?.let { pyData ->
(pyData.pathsAddedByUser + pyData.pathsRemovedByUser).forEach { (localPath, remotePath) ->
pathMappings.add(PathMappingSettings.PathMapping(localPath.toString(), remotePath))
}
}
for (root in stateFile.roots) {
val remoteRootPath = root.path
val localRootName = remoteRootPath.hashCode().toString()
val localRoot = Files.createDirectories(localRemoteSourcesRoot / localRootName)
pathMappings.addMappingCheckUnique(localRoot.toString(), remoteRootPath)
val rootZip = localRemoteSourcesRoot / root.zipName
ZipUtil.extract(rootZip, localRoot, null, true)
for (invalidEntryRelPath in root.invalidEntries) {
val localInvalidEntry = localRoot / PathUtil.toSystemDependentName(invalidEntryRelPath)
LOG.debug("Removing the mapped file $invalidEntryRelPath from $remoteRootPath")
localInvalidEntry.deleteWithParentsIfEmpty(localRemoteSourcesRoot)
}
rootZip.deleteExisting()
}
if (targetWithVfs != null) {
// If target has local VFS, we map locally available roots to VFS instead of copying them to remote_sources
// See how ``updateSdkPaths`` is used
for (remoteRoot in stateFile.skippedRoots) {
val localPath = targetWithVfs.getVfsFromTargetPath(remoteRoot)?.path ?: continue
pathMappings.add(PathMappingSettings.PathMapping(localPath, remoteRoot))
}
}
(sdk.sdkAdditionalData as? RemoteSdkProperties)?.setPathMappings(pathMappings)
val fs = LocalFileSystem.getInstance()
// "remote_sources" folder may now contain new packages
// since we copied them there not via VFS, we must refresh it, so Intellij knows about them
pathMappings.pathMappings.mapNotNull { fs.findFileByPath(it.localRoot) }.forEach { it.refresh(false, true) }
}
private class StateFile {
var roots: List<RootInfo> = emptyList()
@SerializedName("skipped_roots")
var skippedRoots: List<String> = emptyList()
}
private class RootInfo {
var path: String = ""
@SerializedName("zip_name")
var zipName: String = ""
@SerializedName("invalid_entries")
var invalidEntries: List<String> = emptyList()
override fun toString(): String = path
}
companion object {
val LOG = logger<PyTargetsRemoteSourcesRefresher>()
}
}
| python/src/com/jetbrains/python/sdk/PyTargetsRemoteSourcesRefresher.kt | 3627114256 |
// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
package com.intellij.internal.ml
import org.jetbrains.annotations.ApiStatus
@ApiStatus.Internal
interface MLFeature {
val name: String
fun compute(): MLFeatureValueBase
companion object {
fun simple(name: String, value: MLFeatureValueBase): MLFeature = object : MLFeature {
override val name: String = name
override fun compute(): MLFeatureValueBase = value
}
}
}
| platform/ml-api/src/com/intellij/internal/ml/MLFeature.kt | 3686996739 |
// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
package com.intellij.lang.documentation.ide.impl
import com.intellij.codeInsight.documentation.QuickDocUtil.isDocumentationV2Enabled
import com.intellij.codeInsight.lookup.Lookup
import com.intellij.codeInsight.lookup.LookupEx
import com.intellij.codeInsight.lookup.LookupManagerListener
import com.intellij.openapi.project.Project
import com.intellij.openapi.startup.ProjectPostStartupActivity
internal class DocumentationAutoPopup : ProjectPostStartupActivity {
override suspend fun execute(project: Project) {
project.messageBus.connect().subscribe(LookupManagerListener.TOPIC, DocumentationAutoPopupListener())
}
}
private class DocumentationAutoPopupListener : LookupManagerListener {
override fun activeLookupChanged(oldLookup: Lookup?, newLookup: Lookup?) {
if (newLookup is LookupEx && isDocumentationV2Enabled()) {
DocumentationManager.instance(newLookup.project).autoShowDocumentationOnItemChange(newLookup)
}
}
}
| platform/lang-impl/src/com/intellij/lang/documentation/ide/impl/DocumentationAutoPopup.kt | 1836190739 |
actual annotation class <!LINE_MARKER("descr='Has expects in common module'")!>Ann<!>(
actual val <!LINE_MARKER("descr='Has expects in common module'")!>x<!>: Int, actual val y: String,
actual val <!LINE_MARKER("descr='Has expects in common module'")!>z<!>: Double, actual val b: Boolean
)
/*
LINEMARKER: Has declaration in common module
TARGETS:
common.kt
expect annotation class <1>Ann(
*//*
LINEMARKER: Has declaration in common module
TARGETS:
common.kt
val <1>x: Int, val <2>y: String,
*//*
LINEMARKER: Has declaration in common module
TARGETS:
common.kt
val <2>z: Double, val <1>b: Boolean
*/
| plugins/kotlin/idea/tests/testData/multiModuleLineMarker/fromActualAnnotationWithParametersInOneLine/jvm/jvm.kt | 2918676546 |
package com.strumenta.kolasu.language
import com.strumenta.kolasu.model.Node
import com.strumenta.kolasu.model.Position
import com.strumenta.kolasu.parsing.withParseTreeNode
import com.strumenta.simplelang.SimpleLangLexer
import com.strumenta.simplelang.SimpleLangParser
import org.antlr.v4.runtime.CharStreams
import org.antlr.v4.runtime.CommonTokenStream
import org.junit.Test
import kotlin.test.assertEquals
data class CU(val specifiedPosition: Position? = null, var statements: List<Node> = listOf()) : Node(specifiedPosition)
data class DisplayIntStatement(val specifiedPosition: Position? = null, val value: Int) : Node(specifiedPosition)
data class SetStatement(val specifiedPosition: Position? = null, var variable: String = "", val value: Int = 0) :
Node(specifiedPosition)
class UnparserTest {
@Test
fun parserRuleContextPosition() {
val code = "set foo = 123\ndisplay 456"
val lexer = SimpleLangLexer(CharStreams.fromString(code))
val parser = SimpleLangParser(CommonTokenStream(lexer))
val pt = parser.compilationUnit()
val cu = CU(
statements = listOf(
DisplayIntStatement(value = 456).withParseTreeNode(pt.statement(1)),
SetStatement(variable = "foo", value = 123).withParseTreeNode(pt.statement(0))
)
).withParseTreeNode(pt)
assertEquals(code, Unparser().unparse(cu))
}
}
| core/src/test/kotlin/com/strumenta/kolasu/language/UnparserTest.kt | 1325016903 |
package jp.ac.kcg.repository
import jp.ac.kcg.domain.Item
import jp.ac.kcg.domain.User
import org.springframework.data.jpa.repository.JpaRepository
import org.springframework.data.jpa.repository.Query
import org.springframework.data.repository.query.Param
import java.time.LocalDate
interface ItemRepository: JpaRepository<Item, Long> {
@Query("select i from Item i where i.user = :user and :before <= i.receiptDate and i.receiptDate <= :after")
fun searchItems(@Param("user") user: User, @Param("before") before: LocalDate, @Param("after") after: LocalDate): List<Item>
}
| src/main/kotlin/jp/ac/kcg/repository/ItemRepository.kt | 1401421579 |
package org.kethereum.bip39.wordlists
val WORDLIST_FRENCH = listOf("abaisser", "abandon", "abdiquer", "abeille", "abolir", "aborder", "aboutir", "aboyer", "abrasif", "abreuver", "abriter", "abroger", "abrupt", "absence", "absolu", "absurde", "abusif", "abyssal", "académie", "acajou", "acarien", "accabler", "accepter", "acclamer", "accolade", "accroche", "accuser", "acerbe", "achat", "acheter", "aciduler", "acier", "acompte", "acquérir", "acronyme", "acteur", "actif", "actuel", "adepte", "adéquat", "adhésif", "adjectif", "adjuger", "admettre", "admirer", "adopter", "adorer", "adoucir", "adresse", "adroit", "adulte", "adverbe", "aérer", "aéronef", "affaire", "affecter", "affiche", "affreux", "affubler", "agacer", "agencer", "agile", "agiter", "agrafer", "agréable", "agrume", "aider", "aiguille", "ailier", "aimable", "aisance", "ajouter", "ajuster", "alarmer", "alchimie", "alerte", "algèbre", "algue", "aliéner", "aliment", "alléger", "alliage", "allouer", "allumer", "alourdir", "alpaga", "altesse", "alvéole", "amateur", "ambigu", "ambre", "aménager", "amertume", "amidon", "amiral", "amorcer", "amour", "amovible", "amphibie", "ampleur", "amusant", "analyse", "anaphore", "anarchie", "anatomie", "ancien", "anéantir", "angle", "angoisse", "anguleux", "animal", "annexer", "annonce", "annuel", "anodin", "anomalie", "anonyme", "anormal", "antenne", "antidote", "anxieux", "apaiser", "apéritif", "aplanir", "apologie", "appareil", "appeler", "apporter", "appuyer", "aquarium", "aqueduc", "arbitre", "arbuste", "ardeur", "ardoise", "argent", "arlequin", "armature", "armement", "armoire", "armure", "arpenter", "arracher", "arriver", "arroser", "arsenic", "artériel", "article", "aspect", "asphalte", "aspirer", "assaut", "asservir", "assiette", "associer", "assurer", "asticot", "astre", "astuce", "atelier", "atome", "atrium", "atroce", "attaque", "attentif", "attirer", "attraper", "aubaine", "auberge", "audace", "audible", "augurer", "aurore", "automne", "autruche", "avaler", "avancer", "avarice", "avenir", "averse", "aveugle", "aviateur", "avide", "avion", "aviser", "avoine", "avouer", "avril", "axial", "axiome", "badge", "bafouer", "bagage", "baguette", "baignade", "balancer", "balcon", "baleine", "balisage", "bambin", "bancaire", "bandage", "banlieue", "bannière", "banquier", "barbier", "baril", "baron", "barque", "barrage", "bassin", "bastion", "bataille", "bateau", "batterie", "baudrier", "bavarder", "belette", "bélier", "belote", "bénéfice", "berceau", "berger", "berline", "bermuda", "besace", "besogne", "bétail", "beurre", "biberon", "bicycle", "bidule", "bijou", "bilan", "bilingue", "billard", "binaire", "biologie", "biopsie", "biotype", "biscuit", "bison", "bistouri", "bitume", "bizarre", "blafard", "blague", "blanchir", "blessant", "blinder", "blond", "bloquer", "blouson", "bobard", "bobine", "boire", "boiser", "bolide", "bonbon", "bondir", "bonheur", "bonifier", "bonus", "bordure", "borne", "botte", "boucle", "boueux", "bougie", "boulon", "bouquin", "bourse", "boussole", "boutique", "boxeur", "branche", "brasier", "brave", "brebis", "brèche", "breuvage", "bricoler", "brigade", "brillant", "brioche", "brique", "brochure", "broder", "bronzer", "brousse", "broyeur", "brume", "brusque", "brutal", "bruyant", "buffle", "buisson", "bulletin", "bureau", "burin", "bustier", "butiner", "butoir", "buvable", "buvette", "cabanon", "cabine", "cachette", "cadeau", "cadre", "caféine", "caillou", "caisson", "calculer", "calepin", "calibre", "calmer", "calomnie", "calvaire", "camarade", "caméra", "camion", "campagne", "canal", "caneton", "canon", "cantine", "canular", "capable", "caporal", "caprice", "capsule", "capter", "capuche", "carabine", "carbone", "caresser", "caribou", "carnage", "carotte", "carreau", "carton", "cascade", "casier", "casque", "cassure", "causer", "caution", "cavalier", "caverne", "caviar", "cédille", "ceinture", "céleste", "cellule", "cendrier", "censurer", "central", "cercle", "cérébral", "cerise", "cerner", "cerveau", "cesser", "chagrin", "chaise", "chaleur", "chambre", "chance", "chapitre", "charbon", "chasseur", "chaton", "chausson", "chavirer", "chemise", "chenille", "chéquier", "chercher", "cheval", "chien", "chiffre", "chignon", "chimère", "chiot", "chlorure", "chocolat", "choisir", "chose", "chouette", "chrome", "chute", "cigare", "cigogne", "cimenter", "cinéma", "cintrer", "circuler", "cirer", "cirque", "citerne", "citoyen", "citron", "civil", "clairon", "clameur", "claquer", "classe", "clavier", "client", "cligner", "climat", "clivage", "cloche", "clonage", "cloporte", "cobalt", "cobra", "cocasse", "cocotier", "coder", "codifier", "coffre", "cogner", "cohésion", "coiffer", "coincer", "colère", "colibri", "colline", "colmater", "colonel", "combat", "comédie", "commande", "compact", "concert", "conduire", "confier", "congeler", "connoter", "consonne", "contact", "convexe", "copain", "copie", "corail", "corbeau", "cordage", "corniche", "corpus", "correct", "cortège", "cosmique", "costume", "coton", "coude", "coupure", "courage", "couteau", "couvrir", "coyote", "crabe", "crainte", "cravate", "crayon", "créature", "créditer", "crémeux", "creuser", "crevette", "cribler", "crier", "cristal", "critère", "croire", "croquer", "crotale", "crucial", "cruel", "crypter", "cubique", "cueillir", "cuillère", "cuisine", "cuivre", "culminer", "cultiver", "cumuler", "cupide", "curatif", "curseur", "cyanure", "cycle", "cylindre", "cynique", "daigner", "damier", "danger", "danseur", "dauphin", "débattre", "débiter", "déborder", "débrider", "débutant", "décaler", "décembre", "déchirer", "décider", "déclarer", "décorer", "décrire", "décupler", "dédale", "déductif", "déesse", "défensif", "défiler", "défrayer", "dégager", "dégivrer", "déglutir", "dégrafer", "déjeuner", "délice", "déloger", "demander", "demeurer", "démolir", "dénicher", "dénouer", "dentelle", "dénuder", "départ", "dépenser", "déphaser", "déplacer", "déposer", "déranger", "dérober", "désastre", "descente", "désert", "désigner", "désobéir", "dessiner", "destrier", "détacher", "détester", "détourer", "détresse", "devancer", "devenir", "deviner", "devoir", "diable", "dialogue", "diamant", "dicter", "différer", "digérer", "digital", "digne", "diluer", "dimanche", "diminuer", "dioxyde", "directif", "diriger", "discuter", "disposer", "dissiper", "distance", "divertir", "diviser", "docile", "docteur", "dogme", "doigt", "domaine", "domicile", "dompter", "donateur", "donjon", "donner", "dopamine", "dortoir", "dorure", "dosage", "doseur", "dossier", "dotation", "douanier", "double", "douceur", "douter", "doyen", "dragon", "draper", "dresser", "dribbler", "droiture", "duperie", "duplexe", "durable", "durcir", "dynastie", "éblouir", "écarter", "écharpe", "échelle", "éclairer", "éclipse", "éclore", "écluse", "école", "économie", "écorce", "écouter", "écraser", "écrémer", "écrivain", "écrou", "écume", "écureuil", "édifier", "éduquer", "effacer", "effectif", "effigie", "effort", "effrayer", "effusion", "égaliser", "égarer", "éjecter", "élaborer", "élargir", "électron", "élégant", "éléphant", "élève", "éligible", "élitisme", "éloge", "élucider", "éluder", "emballer", "embellir", "embryon", "émeraude", "émission", "emmener", "émotion", "émouvoir", "empereur", "employer", "emporter", "emprise", "émulsion", "encadrer", "enchère", "enclave", "encoche", "endiguer", "endosser", "endroit", "enduire", "énergie", "enfance", "enfermer", "enfouir", "engager", "engin", "englober", "énigme", "enjamber", "enjeu", "enlever", "ennemi", "ennuyeux", "enrichir", "enrobage", "enseigne", "entasser", "entendre", "entier", "entourer", "entraver", "énumérer", "envahir", "enviable", "envoyer", "enzyme", "éolien", "épaissir", "épargne", "épatant", "épaule", "épicerie", "épidémie", "épier", "épilogue", "épine", "épisode", "épitaphe", "époque", "épreuve", "éprouver", "épuisant", "équerre", "équipe", "ériger", "érosion", "erreur", "éruption", "escalier", "espadon", "espèce", "espiègle", "espoir", "esprit", "esquiver", "essayer", "essence", "essieu", "essorer", "estime", "estomac", "estrade", "étagère", "étaler", "étanche", "étatique", "éteindre", "étendoir", "éternel", "éthanol", "éthique", "ethnie", "étirer", "étoffer", "étoile", "étonnant", "étourdir", "étrange", "étroit", "étude", "euphorie", "évaluer", "évasion", "éventail", "évidence", "éviter", "évolutif", "évoquer", "exact", "exagérer", "exaucer", "exceller", "excitant", "exclusif", "excuse", "exécuter", "exemple", "exercer", "exhaler", "exhorter", "exigence", "exiler", "exister", "exotique", "expédier", "explorer", "exposer", "exprimer", "exquis", "extensif", "extraire", "exulter", "fable", "fabuleux", "facette", "facile", "facture", "faiblir", "falaise", "fameux", "famille", "farceur", "farfelu", "farine", "farouche", "fasciner", "fatal", "fatigue", "faucon", "fautif", "faveur", "favori", "fébrile", "féconder", "fédérer", "félin", "femme", "fémur", "fendoir", "féodal", "fermer", "féroce", "ferveur", "festival", "feuille", "feutre", "février", "fiasco", "ficeler", "fictif", "fidèle", "figure", "filature", "filetage", "filière", "filleul", "filmer", "filou", "filtrer", "financer", "finir", "fiole", "firme", "fissure", "fixer", "flairer", "flamme", "flasque", "flatteur", "fléau", "flèche", "fleur", "flexion", "flocon", "flore", "fluctuer", "fluide", "fluvial", "folie", "fonderie", "fongible", "fontaine", "forcer", "forgeron", "formuler", "fortune", "fossile", "foudre", "fougère", "fouiller", "foulure", "fourmi", "fragile", "fraise", "franchir", "frapper", "frayeur", "frégate", "freiner", "frelon", "frémir", "frénésie", "frère", "friable", "friction", "frisson", "frivole", "froid", "fromage", "frontal", "frotter", "fruit", "fugitif", "fuite", "fureur", "furieux", "furtif", "fusion", "futur", "gagner", "galaxie", "galerie", "gambader", "garantir", "gardien", "garnir", "garrigue", "gazelle", "gazon", "géant", "gélatine", "gélule", "gendarme", "général", "génie", "genou", "gentil", "géologie", "géomètre", "géranium", "germe", "gestuel", "geyser", "gibier", "gicler", "girafe", "givre", "glace", "glaive", "glisser", "globe", "gloire", "glorieux", "golfeur", "gomme", "gonfler", "gorge", "gorille", "goudron", "gouffre", "goulot", "goupille", "gourmand", "goutte", "graduel", "graffiti", "graine", "grand", "grappin", "gratuit", "gravir", "grenat", "griffure", "griller", "grimper", "grogner", "gronder", "grotte", "groupe", "gruger", "grutier", "gruyère", "guépard", "guerrier", "guide", "guimauve", "guitare", "gustatif", "gymnaste", "gyrostat", "habitude", "hachoir", "halte", "hameau", "hangar", "hanneton", "haricot", "harmonie", "harpon", "hasard", "hélium", "hématome", "herbe", "hérisson", "hermine", "héron", "hésiter", "heureux", "hiberner", "hibou", "hilarant", "histoire", "hiver", "homard", "hommage", "homogène", "honneur", "honorer", "honteux", "horde", "horizon", "horloge", "hormone", "horrible", "houleux", "housse", "hublot", "huileux", "humain", "humble", "humide", "humour", "hurler", "hydromel", "hygiène", "hymne", "hypnose", "idylle", "ignorer", "iguane", "illicite", "illusion", "image", "imbiber", "imiter", "immense", "immobile", "immuable", "impact", "impérial", "implorer", "imposer", "imprimer", "imputer", "incarner", "incendie", "incident", "incliner", "incolore", "indexer", "indice", "inductif", "inédit", "ineptie", "inexact", "infini", "infliger", "informer", "infusion", "ingérer", "inhaler", "inhiber", "injecter", "injure", "innocent", "inoculer", "inonder", "inscrire", "insecte", "insigne", "insolite", "inspirer", "instinct", "insulter", "intact", "intense", "intime", "intrigue", "intuitif", "inutile", "invasion", "inventer", "inviter", "invoquer", "ironique", "irradier", "irréel", "irriter", "isoler", "ivoire", "ivresse", "jaguar", "jaillir", "jambe", "janvier", "jardin", "jauger", "jaune", "javelot", "jetable", "jeton", "jeudi", "jeunesse", "joindre", "joncher", "jongler", "joueur", "jouissif", "journal", "jovial", "joyau", "joyeux", "jubiler", "jugement", "junior", "jupon", "juriste", "justice", "juteux", "juvénile", "kayak", "kimono", "kiosque", "label", "labial", "labourer", "lacérer", "lactose", "lagune", "laine", "laisser", "laitier", "lambeau", "lamelle", "lampe", "lanceur", "langage", "lanterne", "lapin", "largeur", "larme", "laurier", "lavabo", "lavoir", "lecture", "légal", "léger", "légume", "lessive", "lettre", "levier", "lexique", "lézard", "liasse", "libérer", "libre", "licence", "licorne", "liège", "lièvre", "ligature", "ligoter", "ligue", "limer", "limite", "limonade", "limpide", "linéaire", "lingot", "lionceau", "liquide", "lisière", "lister", "lithium", "litige", "littoral", "livreur", "logique", "lointain", "loisir", "lombric", "loterie", "louer", "lourd", "loutre", "louve", "loyal", "lubie", "lucide", "lucratif", "lueur", "lugubre", "luisant", "lumière", "lunaire", "lundi", "luron", "lutter", "luxueux", "machine", "magasin", "magenta", "magique", "maigre", "maillon", "maintien", "mairie", "maison", "majorer", "malaxer", "maléfice", "malheur", "malice", "mallette", "mammouth", "mandater", "maniable", "manquant", "manteau", "manuel", "marathon", "marbre", "marchand", "mardi", "maritime", "marqueur", "marron", "marteler", "mascotte", "massif", "matériel", "matière", "matraque", "maudire", "maussade", "mauve", "maximal", "méchant", "méconnu", "médaille", "médecin", "méditer", "méduse", "meilleur", "mélange", "mélodie", "membre", "mémoire", "menacer", "mener", "menhir", "mensonge", "mentor", "mercredi", "mérite", "merle", "messager", "mesure", "métal", "météore", "méthode", "métier", "meuble", "miauler", "microbe", "miette", "mignon", "migrer", "milieu", "million", "mimique", "mince", "minéral", "minimal", "minorer", "minute", "miracle", "miroiter", "missile", "mixte", "mobile", "moderne", "moelleux", "mondial", "moniteur", "monnaie", "monotone", "monstre", "montagne", "monument", "moqueur", "morceau", "morsure", "mortier", "moteur", "motif", "mouche", "moufle", "moulin", "mousson", "mouton", "mouvant", "multiple", "munition", "muraille", "murène", "murmure", "muscle", "muséum", "musicien", "mutation", "muter", "mutuel", "myriade", "myrtille", "mystère", "mythique", "nageur", "nappe", "narquois", "narrer", "natation", "nation", "nature", "naufrage", "nautique", "navire", "nébuleux", "nectar", "néfaste", "négation", "négliger", "négocier", "neige", "nerveux", "nettoyer", "neurone", "neutron", "neveu", "niche", "nickel", "nitrate", "niveau", "noble", "nocif", "nocturne", "noirceur", "noisette", "nomade", "nombreux", "nommer", "normatif", "notable", "notifier", "notoire", "nourrir", "nouveau", "novateur", "novembre", "novice", "nuage", "nuancer", "nuire", "nuisible", "numéro", "nuptial", "nuque", "nutritif", "obéir", "objectif", "obliger", "obscur", "observer", "obstacle", "obtenir", "obturer", "occasion", "occuper", "océan", "octobre", "octroyer", "octupler", "oculaire", "odeur", "odorant", "offenser", "officier", "offrir", "ogive", "oiseau", "oisillon", "olfactif", "olivier", "ombrage", "omettre", "onctueux", "onduler", "onéreux", "onirique", "opale", "opaque", "opérer", "opinion", "opportun", "opprimer", "opter", "optique", "orageux", "orange", "orbite", "ordonner", "oreille", "organe", "orgueil", "orifice", "ornement", "orque", "ortie", "osciller", "osmose", "ossature", "otarie", "ouragan", "ourson", "outil", "outrager", "ouvrage", "ovation", "oxyde", "oxygène", "ozone", "paisible", "palace", "palmarès", "palourde", "palper", "panache", "panda", "pangolin", "paniquer", "panneau", "panorama", "pantalon", "papaye", "papier", "papoter", "papyrus", "paradoxe", "parcelle", "paresse", "parfumer", "parler", "parole", "parrain", "parsemer", "partager", "parure", "parvenir", "passion", "pastèque", "paternel", "patience", "patron", "pavillon", "pavoiser", "payer", "paysage", "peigne", "peintre", "pelage", "pélican", "pelle", "pelouse", "peluche", "pendule", "pénétrer", "pénible", "pensif", "pénurie", "pépite", "péplum", "perdrix", "perforer", "période", "permuter", "perplexe", "persil", "perte", "peser", "pétale", "petit", "pétrir", "peuple", "pharaon", "phobie", "phoque", "photon", "phrase", "physique", "piano", "pictural", "pièce", "pierre", "pieuvre", "pilote", "pinceau", "pipette", "piquer", "pirogue", "piscine", "piston", "pivoter", "pixel", "pizza", "placard", "plafond", "plaisir", "planer", "plaque", "plastron", "plateau", "pleurer", "plexus", "pliage", "plomb", "plonger", "pluie", "plumage", "pochette", "poésie", "poète", "pointe", "poirier", "poisson", "poivre", "polaire", "policier", "pollen", "polygone", "pommade", "pompier", "ponctuel", "pondérer", "poney", "portique", "position", "posséder", "posture", "potager", "poteau", "potion", "pouce", "poulain", "poumon", "pourpre", "poussin", "pouvoir", "prairie", "pratique", "précieux", "prédire", "préfixe", "prélude", "prénom", "présence", "prétexte", "prévoir", "primitif", "prince", "prison", "priver", "problème", "procéder", "prodige", "profond", "progrès", "proie", "projeter", "prologue", "promener", "propre", "prospère", "protéger", "prouesse", "proverbe", "prudence", "pruneau", "psychose", "public", "puceron", "puiser", "pulpe", "pulsar", "punaise", "punitif", "pupitre", "purifier", "puzzle", "pyramide", "quasar", "querelle", "question", "quiétude", "quitter", "quotient", "racine", "raconter", "radieux", "ragondin", "raideur", "raisin", "ralentir", "rallonge", "ramasser", "rapide", "rasage", "ratisser", "ravager", "ravin", "rayonner", "réactif", "réagir", "réaliser", "réanimer", "recevoir", "réciter", "réclamer", "récolter", "recruter", "reculer", "recycler", "rédiger", "redouter", "refaire", "réflexe", "réformer", "refrain", "refuge", "régalien", "région", "réglage", "régulier", "réitérer", "rejeter", "rejouer", "relatif", "relever", "relief", "remarque", "remède", "remise", "remonter", "remplir", "remuer", "renard", "renfort", "renifler", "renoncer", "rentrer", "renvoi", "replier", "reporter", "reprise", "reptile", "requin", "réserve", "résineux", "résoudre", "respect", "rester", "résultat", "rétablir", "retenir", "réticule", "retomber", "retracer", "réunion", "réussir", "revanche", "revivre", "révolte", "révulsif", "richesse", "rideau", "rieur", "rigide", "rigoler", "rincer", "riposter", "risible", "risque", "rituel", "rival", "rivière", "rocheux", "romance", "rompre", "ronce", "rondin", "roseau", "rosier", "rotatif", "rotor", "rotule", "rouge", "rouille", "rouleau", "routine", "royaume", "ruban", "rubis", "ruche", "ruelle", "rugueux", "ruiner", "ruisseau", "ruser", "rustique", "rythme", "sabler", "saboter", "sabre", "sacoche", "safari", "sagesse", "saisir", "salade", "salive", "salon", "saluer", "samedi", "sanction", "sanglier", "sarcasme", "sardine", "saturer", "saugrenu", "saumon", "sauter", "sauvage", "savant", "savonner", "scalpel", "scandale", "scélérat", "scénario", "sceptre", "schéma", "science", "scinder", "score", "scrutin", "sculpter", "séance", "sécable", "sécher", "secouer", "sécréter", "sédatif", "séduire", "seigneur", "séjour", "sélectif", "semaine", "sembler", "semence", "séminal", "sénateur", "sensible", "sentence", "séparer", "séquence", "serein", "sergent", "sérieux", "serrure", "sérum", "service", "sésame", "sévir", "sevrage", "sextuple", "sidéral", "siècle", "siéger", "siffler", "sigle", "signal", "silence", "silicium", "simple", "sincère", "sinistre", "siphon", "sirop", "sismique", "situer", "skier", "social", "socle", "sodium", "soigneux", "soldat", "soleil", "solitude", "soluble", "sombre", "sommeil", "somnoler", "sonde", "songeur", "sonnette", "sonore", "sorcier", "sortir", "sosie", "sottise", "soucieux", "soudure", "souffle", "soulever", "soupape", "source", "soutirer", "souvenir", "spacieux", "spatial", "spécial", "sphère", "spiral", "stable", "station", "sternum", "stimulus", "stipuler", "strict", "studieux", "stupeur", "styliste", "sublime", "substrat", "subtil", "subvenir", "succès", "sucre", "suffixe", "suggérer", "suiveur", "sulfate", "superbe", "supplier", "surface", "suricate", "surmener", "surprise", "sursaut", "survie", "suspect", "syllabe", "symbole", "symétrie", "synapse", "syntaxe", "système", "tabac", "tablier", "tactile", "tailler", "talent", "talisman", "talonner", "tambour", "tamiser", "tangible", "tapis", "taquiner", "tarder", "tarif", "tartine", "tasse", "tatami", "tatouage", "taupe", "taureau", "taxer", "témoin", "temporel", "tenaille", "tendre", "teneur", "tenir", "tension", "terminer", "terne", "terrible", "tétine", "texte", "thème", "théorie", "thérapie", "thorax", "tibia", "tiède", "timide", "tirelire", "tiroir", "tissu", "titane", "titre", "tituber", "toboggan", "tolérant", "tomate", "tonique", "tonneau", "toponyme", "torche", "tordre", "tornade", "torpille", "torrent", "torse", "tortue", "totem", "toucher", "tournage", "tousser", "toxine", "traction", "trafic", "tragique", "trahir", "train", "trancher", "travail", "trèfle", "tremper", "trésor", "treuil", "triage", "tribunal", "tricoter", "trilogie", "triomphe", "tripler", "triturer", "trivial", "trombone", "tronc", "tropical", "troupeau", "tuile", "tulipe", "tumulte", "tunnel", "turbine", "tuteur", "tutoyer", "tuyau", "tympan", "typhon", "typique", "tyran", "ubuesque", "ultime", "ultrason", "unanime", "unifier", "union", "unique", "unitaire", "univers", "uranium", "urbain", "urticant", "usage", "usine", "usuel", "usure", "utile", "utopie", "vacarme", "vaccin", "vagabond", "vague", "vaillant", "vaincre", "vaisseau", "valable", "valise", "vallon", "valve", "vampire", "vanille", "vapeur", "varier", "vaseux", "vassal", "vaste", "vecteur", "vedette", "végétal", "véhicule", "veinard", "véloce", "vendredi", "vénérer", "venger", "venimeux", "ventouse", "verdure", "vérin", "vernir", "verrou", "verser", "vertu", "veston", "vétéran", "vétuste", "vexant", "vexer", "viaduc", "viande", "victoire", "vidange", "vidéo", "vignette", "vigueur", "vilain", "village", "vinaigre", "violon", "vipère", "virement", "virtuose", "virus", "visage", "viseur", "vision", "visqueux", "visuel", "vital", "vitesse", "viticole", "vitrine", "vivace", "vivipare", "vocation", "voguer", "voile", "voisin", "voiture", "volaille", "volcan", "voltiger", "volume", "vorace", "vortex", "voter", "vouloir", "voyage", "voyelle", "wagon", "xénon", "yacht", "zèbre", "zénith", "zeste", "zoologie")
| bip39_wordlist_fr/src/main/kotlin/org/kethereum/bip39/wordlists/Wordlist.kt | 151691481 |
package jp.co.devjchankchan.now_slack_android.fragments.content
import android.content.Context
import java.util.ArrayList
import java.util.HashMap
class SlackContent(context: Context) {
private var myContext = context
val ITEMS: MutableList<SlackMenuItem> = ArrayList()
val ITEM_MAP: MutableMap<SlackMenus, SlackMenuItem> = HashMap()
private val COUNT = SlackMenus.values().size
init {
for (i in 0 until COUNT) {
addItem(createItem(i))
}
}
private fun addItem(item: SlackMenuItem) {
ITEMS.add(item)
ITEM_MAP.put(item.id, item)
}
private fun createItem(position: Int): SlackMenuItem = SlackMenuItem(SlackMenus.values().get(position), makeDetails(position))
private fun makeDetails(position: Int): String {
val menu = SlackMenus.values().get(position)
return myContext.getString(menu.stringId)
}
class SlackMenuItem(val id: SlackMenus, val content: String) {
override fun toString(): String = content
}
enum class SlackMenus(val stringId: Int) {
AUTH(jp.co.devjchankchan.physicalbotlibrary.R.string.authentication),
EMOJI_LIST(jp.co.devjchankchan.physicalbotlibrary.R.string.emoji_list),
SET_EMOJI(jp.co.devjchankchan.physicalbotlibrary.R.string.set_emoji),
LOG_OUT(jp.co.devjchankchan.physicalbotlibrary.R.string.log_out)
}
}
| mobile/src/main/java/jp/co/devjchankchan/now_slack_android/fragments/content/SlackContent.kt | 705537911 |
/*
* Copyright © 2013 dvbviewer-controller 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 org.dvbviewer.controller.ui.base
import android.annotation.SuppressLint
import android.graphics.PorterDuff
import android.os.Bundle
import android.os.Handler
import android.os.Looper
import android.util.Log
import android.view.Gravity
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.view.animation.AnimationUtils
import android.widget.*
import androidx.appcompat.widget.AppCompatTextView
import androidx.core.content.ContextCompat
import org.dvbviewer.controller.R
import org.dvbviewer.controller.data.api.io.exception.AuthenticationException
import org.dvbviewer.controller.data.api.io.exception.DefaultHttpException
import org.xml.sax.SAXException
/**
* Class to mimic API of ListActivity for Fragments
*
* @author RayBa
*/
/**
* Instantiates a new base list fragment.
*/
open class BaseListFragment : BaseFragment() {
private val mHandler = Handler()
private val mRequestFocus = Runnable { mList!!.focusableViewAvailable(mList) }
private val mOnClickListener = AdapterView.OnItemClickListener { parent, v, position, id -> onListItemClick(parent as ListView, v, position, id) }
private var mAdapter: ListAdapter? = null
private var mList: ListView? = null
private var mEmptyView: View? = null
private var mStandardEmptyView: AppCompatTextView? = null
private var mProgressContainer: View? = null
private var mListContainer: View? = null
private var mEmptyText: CharSequence? = null
private var mListShown: Boolean = false
private val handler: Handler = Handler(Looper.getMainLooper())
/**
* Get the activity's list view widget.
*
* @return the list view
*/
val listView: ListView?
get() {
ensureList()
return mList
}
/**
* Get the ListAdapter associated with this activity's ListView.
*
* @return the list adapter
*/
/**
* Provide the mCursor for the list view.
*
* @param adapter the new list adapter
*/
// The list was hidden, and previously didn't have an
// adapter. It is now time to show it.
var listAdapter: ListAdapter?
get() = mAdapter
set(adapter) {
val hadAdapter = mAdapter != null
mAdapter = adapter
if (mList != null) {
mList?.adapter = adapter
if (!mListShown && !hadAdapter) {
setListShown(true, view != null && view!!.windowToken != null)
}
}
}
/**
* Possibility for sublasses to provide a custom layout ressource.
*
* @return the layout resource id
*/
protected open val layoutRessource: Int
get() = -1
/**
* Gets the checked item count.
*
* @return the checked item count
*/
val checkedItemCount: Int
get() {
var count = 0
val checkedPositions = listView!!.checkedItemPositions
if (checkedPositions != null) {
val size = checkedPositions.size()
if (size > 0) {
for (i in 0 until size) {
if (checkedPositions.valueAt(i)) {
count++
}
}
}
}
return count
}
/**
* Provide default implementation to return a simple list view. Subclasses
* can override to replace with their own layout. If doing so, the
* returned view hierarchy *must* have a ListView whose id
* is [android.R.id.list] and can optionally
* have a sibling view id [android.R.id.empty]
* that is to be shown when the list is empty.
*
*
* If you are overriding this method with your own custom content,
* consider including the standard layout [android.R.layout.list_content]
* in your layout file, so that you continue to retain all of the standard
* behavior of ListFragment. In particular, this is currently the only
* way to have the built-in indeterminant progress state be shown.
*
* @param inflater the inflater
* @param container the container
* @param savedInstanceState the saved instance state
* @return the view©
*/
override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?): View? {
val layoutRes = layoutRessource
if (layoutRes > 0) {
return inflater.inflate(layoutRes, container, false)
} else {
val context = context
val root = FrameLayout(context!!)
// ------------------------------------------------------------------
val pframe = LinearLayout(context)
pframe.id = INTERNAL_PROGRESS_CONTAINER_ID
pframe.orientation = LinearLayout.VERTICAL
pframe.visibility = View.GONE
pframe.gravity = Gravity.CENTER
val progress = ProgressBar(context)
getContext()?.let { ContextCompat.getColor(it, R.color.colorControlActivated) }?.let {
progress.indeterminateDrawable
.setColorFilter(it, PorterDuff.Mode.SRC_IN)
}
pframe.addView(progress, FrameLayout.LayoutParams(
ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT))
root.addView(pframe, FrameLayout.LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT))
// ------------------------------------------------------------------
val lframe = FrameLayout(context)
lframe.id = INTERNAL_LIST_CONTAINER_ID
val tv = AppCompatTextView(context)
tv.id = INTERNAL_EMPTY_ID
tv.gravity = Gravity.CENTER
tv.setPadding(15, 0, 15, 0)
lframe.addView(tv, FrameLayout.LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT))
val lv = ListView(context)
lv.id = android.R.id.list
lv.isDrawSelectorOnTop = false
lframe.addView(lv, FrameLayout.LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT))
root.addView(lframe, FrameLayout.LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT))
// ------------------------------------------------------------------
root.layoutParams = FrameLayout.LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)
return root
}
}
/**
* Attach to list view once the view hierarchy has been created.
*
* @param view the view
* @param savedInstanceState the saved instance state
*/
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
ensureList()
}
/**
* Detach from list view.
*/
override fun onDestroyView() {
mHandler.removeCallbacks(mRequestFocus)
mList = null
mListShown = false
mListContainer = null
mProgressContainer = mListContainer
mEmptyView = mProgressContainer
mStandardEmptyView = null
super.onDestroyView()
}
/**
* This method will be called when an item in the list is selected.
* Subclasses should override. Subclasses can call
* getListView().getItemAtPosition(position) if they need to access the
* data associated with the selected item.
*
* @param l The ListView where the click happened
* @param v The view that was clicked within the ListView
* @param position The position of the view in the list
* @param id The row id of the item that was clicked
*/
open fun onListItemClick(l: ListView, v: View, position: Int, id: Long) {}
/**
* Set the currently selected list item to the specified
* position with the adapter's data.
*
* @param position the new selection
*/
@SuppressLint("NewApi")
open fun setSelection(position: Int) {
try {
ensureList()
} catch (e: Exception) {
return
}
mList?.setSelection(position)
}
/**
* The default content for a ListFragment has a TextView that can
* be shown when the list is empty. If you would like to have it
* shown, call this method to supply the text it should use.
*
* @param text the new empty text
*/
fun setEmptyText(text: CharSequence?) {
if (text == null) {
return
}
ensureList()
if (mStandardEmptyView != null) {
mStandardEmptyView!!.text = text
if (mEmptyText == null) {
mList!!.emptyView = mStandardEmptyView
}
}
mEmptyText = text
}
/**
* Control whether the list is being displayed. You can make it not
* displayed if you are waiting for the initial data to show in it. During
* this time an indeterminant progress indicator will be shown instead.
*
*
* Applications do not normally need to use this themselves. The default
* behavior of ListFragment is to start with the list not being shown, only
* showing it once an adapter is given with [.setListAdapter].
* If the list at that point had not been shown, when it does get shown
* it will be do without the user ever seeing the hidden state.
*
* @param shown If true, the list view is shown; if false, the progress
* indicator. The initial value is true.
*/
fun setListShown(shown: Boolean) {
setListShown(shown, true)
}
/**
* Control whether the list is being displayed. You can make it not
* displayed if you are waiting for the initial data to show in it. During
* this time an indeterminant progress indicator will be shown instead.
*
* @param shown If true, the list view is shown; if false, the progress
* indicator. The initial value is true.
* @param animate If true, an animation will be used to transition to the
* new state.
*/
private fun setListShown(shown: Boolean, animate: Boolean) {
try {
ensureList()
} catch (e: Exception) {
return
}
if (mProgressContainer == null) {
throw IllegalStateException("Can't be used with a custom content view")
}
if (mListShown == shown) {
return
}
mListShown = shown
if (shown) {
if (animate) {
mProgressContainer!!.startAnimation(AnimationUtils.loadAnimation(
context, android.R.anim.fade_out))
mListContainer!!.startAnimation(AnimationUtils.loadAnimation(
context, android.R.anim.fade_in))
} else {
mProgressContainer!!.clearAnimation()
mListContainer!!.clearAnimation()
}
mProgressContainer!!.visibility = View.GONE
mListContainer!!.visibility = View.VISIBLE
} else {
if (animate) {
mProgressContainer!!.startAnimation(AnimationUtils.loadAnimation(
context, android.R.anim.fade_in))
mListContainer!!.startAnimation(AnimationUtils.loadAnimation(
context, android.R.anim.fade_out))
} else {
mProgressContainer!!.clearAnimation()
mListContainer!!.clearAnimation()
}
mProgressContainer!!.visibility = View.VISIBLE
mListContainer!!.visibility = View.GONE
}
}
/**
* Ensure list.
*
*/
private fun ensureList() {
if (mList != null) {
return
}
val root = view ?: throw IllegalStateException("Content view not yet created")
if (root is ListView) {
mList = root
} else {
mStandardEmptyView = root.findViewById<View>(INTERNAL_EMPTY_ID) as AppCompatTextView
if (mStandardEmptyView == null) {
mEmptyView = root.findViewById(android.R.id.empty)
} else {
mStandardEmptyView!!.visibility = View.GONE
}
mProgressContainer = root.findViewById(INTERNAL_PROGRESS_CONTAINER_ID)
mListContainer = root.findViewById(INTERNAL_LIST_CONTAINER_ID)
val rawListView = root.findViewById<View>(android.R.id.list)
if (rawListView !is ListView) {
if (rawListView == null) {
throw RuntimeException(
"Your content must have a ListView whose id attribute is " + "'android.R.id.list'")
}
throw RuntimeException(
"Content has view with id attribute 'android.R.id.list' " + "that is not a ListView class")
}
mList = rawListView
if (mEmptyView != null) {
mList!!.emptyView = mEmptyView
} else if (mEmptyText != null) {
mStandardEmptyView!!.text = mEmptyText
mList!!.emptyView = mStandardEmptyView
}
}
mListShown = true
mList!!.onItemClickListener = mOnClickListener
if (mAdapter != null) {
val adapter = mAdapter
mAdapter = null
listAdapter = adapter
} else {
// We are starting without an adapter, so assume we won't
// have our data right away and start with the progress indicator.
if (mProgressContainer != null) {
setListShown(shown = false, animate = false)
}
}
mHandler.post(mRequestFocus)
}
/**
* Generic method to catch an Exception.
* It shows a toast to inform the user.
* This method is safe to be called from non UI threads.
*
* @param tag for logging
* @param e the Excetpion to catch
*/
override fun catchException(tag: String, e: Throwable?) {
if (context == null || isDetached) {
return
}
Log.e(tag, "Error loading ListData", e)
val message = when (e) {
is AuthenticationException -> getString(R.string.error_invalid_credentials)
is DefaultHttpException -> e.message
is SAXException -> getString(R.string.error_parsing_xml)
else -> getStringSafely(R.string.error_common) + "\n\n" + if (e?.message != null) e.message else e?.javaClass?.name
}
handler.post {
message?.let { setEmptyText(it) }
}
}
companion object {
private const val INTERNAL_EMPTY_ID = android.R.id.empty
private const val INTERNAL_PROGRESS_CONTAINER_ID = android.R.id.progress
private const val INTERNAL_LIST_CONTAINER_ID = android.R.id.content
}
} | dvbViewerController/src/main/java/org/dvbviewer/controller/ui/base/BaseListFragment.kt | 2270385083 |
/*
* Copyright 2014-2021 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
*/
package io.ktor.client.plugins.cookies
import io.ktor.http.*
/**
* [CookiesStorage] that ignores [addCookie] and returns a list of specified [cookies] when constructed.
*/
public class ConstantCookiesStorage(vararg cookies: Cookie) : CookiesStorage {
private val storage: List<Cookie> = cookies.map { it.fillDefaults(URLBuilder().build()) }.toList()
override suspend fun get(requestUrl: Url): List<Cookie> = storage.filter { it.matches(requestUrl) }
override suspend fun addCookie(requestUrl: Url, cookie: Cookie) {}
override fun close() {}
}
| ktor-client/ktor-client-core/common/src/io/ktor/client/plugins/cookies/ConstantCookiesStorage.kt | 3640500305 |
package lt.markmerkk.utils
import lt.markmerkk.Const
import lt.markmerkk.Tags
import lt.markmerkk.entities.isEmpty
import org.slf4j.LoggerFactory
import java.net.URI
import java.net.URISyntaxException
object UriUtils {
private val logger = LoggerFactory.getLogger(Tags.INTERNAL)!!
/**
* Takes in worklog uri and parses out remote ID of it
* @return ID or [Consts.NO_ID]
*/
fun parseUri(url: String?): Long {
if (url.isEmpty()) return Const.NO_ID
try {
val uri = URI(url)
val segments = uri.path.split("/")
.dropLastWhile { it.isEmpty() }
.toTypedArray()
val idString = segments[segments.size - 1]
return java.lang.Long.parseLong(idString)
} catch (e: URISyntaxException) {
return Const.NO_ID
} catch (e: NumberFormatException) {
return Const.NO_ID
}
}
} | models/src/main/java/lt/markmerkk/utils/UriUtils.kt | 2750734791 |
package com.example.android.architecture.blueprints.todoapp.statistics
import com.example.android.architecture.blueprints.todoapp.mvibase.MviAction
sealed class StatisticsAction : MviAction {
object LoadStatisticsAction : StatisticsAction()
}
| app/src/main/java/com/example/android/architecture/blueprints/todoapp/statistics/StatisticsAction.kt | 2654612696 |
package eu.kanade.tachiyomi.widget.listener
import android.view.animation.Animation
open class SimpleAnimationListener : Animation.AnimationListener {
override fun onAnimationRepeat(animation: Animation) {}
override fun onAnimationEnd(animation: Animation) {}
override fun onAnimationStart(animation: Animation) {}
}
| app/src/main/java/eu/kanade/tachiyomi/widget/listener/SimpleAnimationListener.kt | 240553466 |
package graphics.scenery.attribute.material
import graphics.scenery.Blending
import graphics.scenery.attribute.material.Material.CullingMode.*
import graphics.scenery.textures.Texture
import graphics.scenery.utils.TimestampedConcurrentHashMap
import org.joml.Vector3f
/**
* Material interface, storing material colors, textures, opacity properties, etc.
*
* @author Ulrik Günther <[email protected]>
*/
interface Material {
/**
* Culling Mode enum, to determine which faces are culling when assuming CCW order
* [Front] - front faces culled
* [Back] - back faces culled
* [FrontAndBack] - all faces culled
* [None] - no faces culled
*/
enum class CullingMode { None, Front, Back, FrontAndBack }
/** Depth test enum, determines which operation on the depth buffer values results in a pass. */
enum class DepthTest { Less, Greater, LessEqual, GreaterEqual, Always, Never, Equal }
/** Name of the material. */
var name: String
/** Diffuse color of the material. */
var diffuse: Vector3f
/** Specular color of the material. */
var specular: Vector3f
/** Ambient color of the material. */
var ambient: Vector3f
/** Specular exponent */
var roughness: Float
/** Metallicity, 0.0 is non-metal, 1.0 is full metal */
var metallic: Float
/** Blending settings for this material. See [Blending]. */
var blending: Blending
/** Hash map storing the type and origin of the material's textures. Key is the
* type, e.g. ("diffuse", "normal", "displacement"...), value can be a file path or
* via "fromBuffer:[transferTextureName], a named [Texture] in [transferTextures]. */
var textures: TimestampedConcurrentHashMap<String, Texture>
/** Culling mode of the material. @see[CullingMode] */
var cullingMode: CullingMode
/** depth testing mode for this material */
var depthTest: DepthTest
/** Flag to make the object wireframe */
var wireframe: Boolean
/**
* Returns a hash of the material, with properties relevant for
* presentation taken into account. Does not include [textures], as
* these are timetamped now.
*/
fun materialHashCode() : Int {
var result = blending.hashCode()
result = 31 * result + cullingMode.hashCode()
result = 31 * result + depthTest.hashCode()
result = 31 * result + wireframe.hashCode()
return result
}
}
| src/main/kotlin/graphics/scenery/attribute/material/Material.kt | 2438630210 |
package org.fountainmc.api.event
interface Cancellable {
var isCancelled: Boolean
}
| src/main/kotlin/org/fountainmc/api/event/Cancellable.kt | 1811163524 |
/*
* Copyright LWJGL. All rights reserved.
* License terms: https://www.lwjgl.org/license
*/
package llvm.templates
import llvm.*
import org.lwjgl.generator.*
val ClangIndex = "ClangIndex".nativeClass(
Module.LLVM,
prefixConstant = "CX",
prefixMethod = "clang_",
binding = CLANG_BINDING
) {
nativeImport("clang-c/Index.h")
IntConstant(
"",
"CINDEX_VERSION_MAJOR".."0",
"CINDEX_VERSION_MINOR".."62",
"CINDEX_VERSION".."CINDEX_VERSION_MAJOR*10000 + CINDEX_VERSION_MINOR"
).noPrefix()
StringConstant(
"",
"CINDEX_VERSION_STRING".."0.62"
).noPrefix()
EnumConstant(
"""
Error codes returned by libclang routines. ({@code enum CXErrorCode})
Zero ({@code CXError_Success}) is the only error code indicating success. Other error codes, including not yet assigned non-zero values, indicate
errors.
""",
"Error_Success".enum("No error.", "0"),
"Error_Failure".enum(
"""
A generic error code, no further details are available.
Errors of this kind can get their own specific error codes in future libclang versions.
"""
),
"Error_Crashed".enum("libclang crashed while performing the requested operation."),
"Error_InvalidArguments".enum("The function detected that the arguments violate the function contract."),
"Error_ASTReadError".enum("An AST deserialization error has occurred.")
)
EnumConstant(
"""
Describes the availability of a particular entity, which indicates whether the use of this entity will result in a warning or error due to it being
deprecated or unavailable.
({@code enum CXAvailabilityKind})
""",
"Availability_Available".enum("The entity is available.", "0"),
"Availability_Deprecated".enum("The entity is available, but has been deprecated (and its use is not recommended)."),
"Availability_NotAvailable".enum("The entity is not available; any use of it will be an error."),
"Availability_NotAccessible".enum("The entity is available, but not accessible; any use of it will be an error.")
)
EnumConstant(
"""
Describes the exception specification of a cursor. ({@code enum CXCursor_ExceptionSpecificationKind})
A negative value indicates that the cursor is not a function declaration.
""",
"Cursor_ExceptionSpecificationKind_None".enum("The cursor has no exception specification.", "0"),
"Cursor_ExceptionSpecificationKind_DynamicNone".enum("The cursor has exception specification throw()"),
"Cursor_ExceptionSpecificationKind_Dynamic".enum("The cursor has exception specification throw(T1, T2)"),
"Cursor_ExceptionSpecificationKind_MSAny".enum("The cursor has exception specification throw(...)."),
"Cursor_ExceptionSpecificationKind_BasicNoexcept".enum("The cursor has exception specification basic noexcept."),
"Cursor_ExceptionSpecificationKind_ComputedNoexcept".enum("The cursor has exception specification computed noexcept."),
"Cursor_ExceptionSpecificationKind_Unevaluated".enum("The exception specification has not yet been evaluated."),
"Cursor_ExceptionSpecificationKind_Uninstantiated".enum("The exception specification has not yet been instantiated."),
"Cursor_ExceptionSpecificationKind_Unparsed".enum("The exception specification has not been parsed yet."),
"Cursor_ExceptionSpecificationKind_NoThrow".enum("The cursor has a {@code __declspec(nothrow)} exception specification.")
)
EnumConstant(
"{@code CXGlobalOptFlags}",
"GlobalOpt_None".enum("Used to indicate that no special CXIndex options are needed.", "0x0"),
"GlobalOpt_ThreadBackgroundPriorityForIndexing".enum(
"""
Used to indicate that threads that libclang creates for indexing purposes should use background priority.
Affects #indexSourceFile(), #indexTranslationUnit(), #parseTranslationUnit(), #saveTranslationUnit().
""",
"0x1"
),
"GlobalOpt_ThreadBackgroundPriorityForEditing".enum(
"""
Used to indicate that threads that libclang creates for editing purposes should use background priority.
Affects #reparseTranslationUnit(), #codeCompleteAt(), #annotateTokens()
""",
"0x2"
),
"GlobalOpt_ThreadBackgroundPriorityForAll".enum(
"Used to indicate that all threads that libclang creates should use background priority.",
"CXGlobalOpt_ThreadBackgroundPriorityForIndexing | CXGlobalOpt_ThreadBackgroundPriorityForEditing"
)
)
EnumConstant(
"""
Describes the severity of a particular diagnostic.
({@code enum CXDiagnosticSeverity})
""",
"Diagnostic_Ignored".enum("A diagnostic that has been suppressed, e.g., by a command-line option.", "0"),
"Diagnostic_Note".enum("This diagnostic is a note that should be attached to the previous (non-note) diagnostic."),
"Diagnostic_Warning".enum("This diagnostic indicates suspicious code that may not be wrong."),
"Diagnostic_Error".enum("This diagnostic indicates that the code is ill-formed."),
"Diagnostic_Fatal".enum(
"This diagnostic indicates that the code is ill-formed such that future parser recovery is unlikely to produce useful results."
)
)
EnumConstant(
"""
Describes the kind of error that occurred (if any) in a call to {@code clang_loadDiagnostics}.
({@code enum CXLoadDiag_Error})
""",
"LoadDiag_None".enum("Indicates that no error occurred.", "0"),
"LoadDiag_Unknown".enum("Indicates that an unknown error occurred while attempting to deserialize diagnostics."),
"LoadDiag_CannotLoad".enum("Indicates that the file containing the serialized diagnostics could not be opened."),
"LoadDiag_InvalidFile".enum("Indicates that the serialized diagnostics file is invalid or corrupt.")
)
EnumConstant(
"""
Options to control the display of diagnostics. ({@code enum CXDiagnosticDisplayOptions})
The values in this enum are meant to be combined to customize the behavior of {@code clang_formatDiagnostic()}.
""",
"Diagnostic_DisplaySourceLocation".enum(
"""
Display the source-location information where the diagnostic was located.
When set, diagnostics will be prefixed by the file, line, and (optionally) column to which the diagnostic refers. For example,
${codeBlock("""
test.c:28: warning: extra tokens at end of \#endif directive""")}
This option corresponds to the clang flag {@code -fshow-source-location}.
""",
"0x01"
),
"Diagnostic_DisplayColumn".enum(
"""
If displaying the source-location information of the diagnostic, also include the column number.
This option corresponds to the clang flag {@code -fshow-column}.
""",
"0x02"
),
"Diagnostic_DisplaySourceRanges".enum(
"""
If displaying the source-location information of the diagnostic, also include information about source ranges in a machine-parsable format.
This option corresponds to the clang flag {@code -fdiagnostics-print-source-range-info}.
""",
"0x04"
),
"Diagnostic_DisplayOption".enum(
"""
Display the option name associated with this diagnostic, if any.
The option name displayed (e.g., -Wconversion) will be placed in brackets after the diagnostic text. This option corresponds to the clang flag
{@code -fdiagnostics-show-option}.
""",
"0x08"
),
"Diagnostic_DisplayCategoryId".enum(
"""
Display the category number associated with this diagnostic, if any.
The category number is displayed within brackets after the diagnostic text. This option corresponds to the clang flag {@code
-fdiagnostics-show-category=id}.
""",
"0x10"
),
"Diagnostic_DisplayCategoryName".enum(
"""
Display the category name associated with this diagnostic, if any.
The category name is displayed within brackets after the diagnostic text. This option corresponds to the clang flag {@code
-fdiagnostics-show-category=name}.
""",
"0x20"
)
)
EnumConstant(
"""
Flags that control the creation of translation units. ({@code enum CXTranslationUnit_Flags})
The enumerators in this enumeration type are meant to be bitwise ORed together to specify which options should be used when constructing the
translation unit.
""",
"TranslationUnit_None".enum("Used to indicate that no special translation-unit options are needed.", "0x0"),
"TranslationUnit_DetailedPreprocessingRecord".enum(
"""
Used to indicate that the parser should construct a "detailed" preprocessing record, including all macro definitions and instantiations.
Constructing a detailed preprocessing record requires more memory and time to parse, since the information contained in the record is usually not
retained. However, it can be useful for applications that require more detailed information about the behavior of the preprocessor.
""",
"0x01"
),
"TranslationUnit_Incomplete".enum(
"""
Used to indicate that the translation unit is incomplete.
When a translation unit is considered "incomplete", semantic analysis that is typically performed at the end of the translation unit will be
suppressed. For example, this suppresses the completion of tentative declarations in C and of instantiation of implicitly-instantiation function
templates in C++. This option is typically used when parsing a header with the intent of producing a precompiled header.
""",
"0x02"
),
"TranslationUnit_PrecompiledPreamble".enum(
"""
Used to indicate that the translation unit should be built with an implicit precompiled header for the preamble.
An implicit precompiled header is used as an optimization when a particular translation unit is likely to be reparsed many times when the sources
aren't changing that often. In this case, an implicit precompiled header will be built containing all of the initial includes at the top of the
main file (what we refer to as the "preamble" of the file). In subsequent parses, if the preamble or the files in it have not changed, {@code
clang_reparseTranslationUnit()} will re-use the implicit precompiled header to improve parsing performance.
""",
"0x04"
),
"TranslationUnit_CacheCompletionResults".enum(
"""
Used to indicate that the translation unit should cache some code-completion results with each reparse of the source file.
Caching of code-completion results is a performance optimization that introduces some overhead to reparsing but improves the performance of
code-completion operations.
""",
"0x08"
),
"TranslationUnit_ForSerialization".enum(
"""
Used to indicate that the translation unit will be serialized with {@code clang_saveTranslationUnit}.
This option is typically used when parsing a header with the intent of producing a precompiled header.
""",
"0x10"
),
"TranslationUnit_CXXChainedPCH".enum(
"""
DEPRECATED: Enabled chained precompiled preambles in C++.
Note: this is a *temporary* option that is available only while we are testing C++ precompiled preamble support. It is deprecated.
""",
"0x20"
),
"TranslationUnit_SkipFunctionBodies".enum(
"""
Used to indicate that function/method bodies should be skipped while parsing.
This option can be used to search for declarations/definitions while ignoring the usages.
""",
"0x40"
),
"TranslationUnit_IncludeBriefCommentsInCodeCompletion".enum(
"Used to indicate that brief documentation comments should be included into the set of code completions returned from this translation unit.",
"0x80"
),
"TranslationUnit_CreatePreambleOnFirstParse".enum(
"""
Used to indicate that the precompiled preamble should be created on the first parse. Otherwise it will be created on the first reparse. This trades
runtime on the first parse (serializing the preamble takes time) for reduced runtime on the second parse (can now reuse the preamble).
""",
"0x100"
),
"TranslationUnit_KeepGoing".enum(
"""
Do not stop processing when fatal errors are encountered.
When fatal errors are encountered while parsing a translation unit, semantic analysis is typically stopped early when compiling code. A common
source for fatal errors are unresolvable include files. For the purposes of an IDE, this is undesirable behavior and as much information as
possible should be reported. Use this flag to enable this behavior.
""",
"0x200"
),
"TranslationUnit_SingleFileParse".enum("Sets the preprocessor in a mode for parsing a single file only.", "0x400"),
"TranslationUnit_LimitSkipFunctionBodiesToPreamble".enum(
"""
Used in combination with CXTranslationUnit_SkipFunctionBodies to constrain the skipping of function bodies to the preamble.
The function bodies of the main file are not skipped.
""",
"0x800"
),
"TranslationUnit_IncludeAttributedTypes".enum("Used to indicate that attributed types should be included in CXType.", "0x1000"),
"TranslationUnit_VisitImplicitAttributes".enum("Used to indicate that implicit attributes should be visited.", "0x2000"),
"TranslationUnit_IgnoreNonErrorsFromIncludedFiles".enum(
"""
Used to indicate that non-errors from included files should be ignored.
If set, #getDiagnosticSetFromTU() will not report e.g. warnings from included files anymore. This speeds up {@code clang_getDiagnosticSetFromTU()}
for the case where these warnings are not of interest, as for an IDE for example, which typically shows only the diagnostics in the main file.
""",
"0x4000"
),
"TranslationUnit_RetainExcludedConditionalBlocks".enum("Tells the preprocessor not to skip excluded conditional blocks.", "0x8000")
)
EnumConstant(
"""
Flags that control how translation units are saved. ({@code enum CXSaveTranslationUnit_Flags})
The enumerators in this enumeration type are meant to be bitwise ORed together to specify which options should be used when saving the translation
unit.
""",
"SaveTranslationUnit_None".enum("Used to indicate that no special saving options are needed.", "0x0")
)
EnumConstant(
"""
Describes the kind of error that occurred (if any) in a call to {@code clang_saveTranslationUnit()}.
({@code enum CXSaveError})
""",
"SaveError_None".enum("Indicates that no error occurred while saving a translation unit.", "0"),
"SaveError_Unknown".enum(
"""
Indicates that an unknown error occurred while attempting to save the file.
This error typically indicates that file I/O failed when attempting to write the file.
"""
),
"SaveError_TranslationErrors".enum(
"""
Indicates that errors during translation prevented this attempt to save the translation unit.
Errors that prevent the translation unit from being saved can be extracted using {@code clang_getNumDiagnostics()} and {@code
clang_getDiagnostic()}.
"""
),
"SaveError_InvalidTU".enum("Indicates that the translation unit to be saved was somehow invalid (e.g., #NULL).")
)
EnumConstant(
"""
Flags that control the reparsing of translation units. ({@code enum CXReparse_Flags})
The enumerators in this enumeration type are meant to be bitwise ORed together to specify which options should be used when reparsing the translation
unit.
""",
"Reparse_None".enum("Used to indicate that no special reparsing options are needed.", "0x0")
)
EnumConstant(
"""
Categorizes how memory is being used by a translation unit.
({@code enum CXTUResourceUsageKind})
""",
"TUResourceUsage_AST".enum("", "1"),
"TUResourceUsage_Identifiers".enum,
"TUResourceUsage_Selectors".enum,
"TUResourceUsage_GlobalCompletionResults".enum,
"TUResourceUsage_SourceManagerContentCache".enum,
"TUResourceUsage_AST_SideTables".enum,
"TUResourceUsage_SourceManager_Membuffer_Malloc".enum,
"TUResourceUsage_SourceManager_Membuffer_MMap".enum,
"TUResourceUsage_ExternalASTSource_Membuffer_Malloc".enum,
"TUResourceUsage_ExternalASTSource_Membuffer_MMap".enum,
"TUResourceUsage_Preprocessor".enum,
"TUResourceUsage_PreprocessingRecord".enum,
"TUResourceUsage_SourceManager_DataStructures".enum,
"TUResourceUsage_Preprocessor_HeaderSearch".enum,
"TUResourceUsage_MEMORY_IN_BYTES_BEGIN".enum("", "CXTUResourceUsage_AST"),
"TUResourceUsage_MEMORY_IN_BYTES_END".enum("", "CXTUResourceUsage_Preprocessor_HeaderSearch"),
"TUResourceUsage_First".enum("", "CXTUResourceUsage_AST"),
"TUResourceUsage_Last".enum("", "CXTUResourceUsage_Preprocessor_HeaderSearch")
)
EnumConstant(
"""
Describes the kind of entity that a cursor refers to.
({@code enum CXCursorKind})
""",
"Cursor_UnexposedDecl".enum(
"""
Declarations
A declaration whose specific kind is not exposed via this interface.
Unexposed declarations have the same operations as any other kind of declaration; one can extract their location information, spelling, find their
definitions, etc. However, the specific kind of the declaration is not reported.
""",
"1"
),
"Cursor_StructDecl".enum("A C or C++ struct."),
"Cursor_UnionDecl".enum("A C or C++ union."),
"Cursor_ClassDecl".enum("A C++ class."),
"Cursor_EnumDecl".enum("An enumeration."),
"Cursor_FieldDecl".enum("A field (in C) or non-static data member (in C++) in a struct, union, or C++ class."),
"Cursor_EnumConstantDecl".enum("An enumerator constant."),
"Cursor_FunctionDecl".enum("A function."),
"Cursor_VarDecl".enum("A variable."),
"Cursor_ParmDecl".enum("A function or method parameter."),
"Cursor_ObjCInterfaceDecl".enum("An Objective-C @ interface."),
"Cursor_ObjCCategoryDecl".enum("An Objective-C @ interface for a category."),
"Cursor_ObjCProtocolDecl".enum("An Objective-C @ protocol declaration."),
"Cursor_ObjCPropertyDecl".enum("An Objective-C @ property declaration."),
"Cursor_ObjCIvarDecl".enum("An Objective-C instance variable."),
"Cursor_ObjCInstanceMethodDecl".enum("An Objective-C instance method."),
"Cursor_ObjCClassMethodDecl".enum("An Objective-C class method."),
"Cursor_ObjCImplementationDecl".enum("An Objective-C @ implementation."),
"Cursor_ObjCCategoryImplDecl".enum("An Objective-C @ implementation for a category."),
"Cursor_TypedefDecl".enum("A typedef."),
"Cursor_CXXMethod".enum("A C++ class method."),
"Cursor_Namespace".enum("A C++ namespace."),
"Cursor_LinkageSpec".enum("A linkage specification, e.g. 'extern \"C\"'."),
"Cursor_Constructor".enum("A C++ constructor."),
"Cursor_Destructor".enum("A C++ destructor."),
"Cursor_ConversionFunction".enum("A C++ conversion function."),
"Cursor_TemplateTypeParameter".enum("A C++ template type parameter."),
"Cursor_NonTypeTemplateParameter".enum("A C++ non-type template parameter."),
"Cursor_TemplateTemplateParameter".enum("A C++ template template parameter."),
"Cursor_FunctionTemplate".enum("A C++ function template."),
"Cursor_ClassTemplate".enum("A C++ class template."),
"Cursor_ClassTemplatePartialSpecialization".enum("A C++ class template partial specialization."),
"Cursor_NamespaceAlias".enum("A C++ namespace alias declaration."),
"Cursor_UsingDirective".enum("A C++ using directive."),
"Cursor_UsingDeclaration".enum("A C++ using declaration."),
"Cursor_TypeAliasDecl".enum("A C++ alias declaration"),
"Cursor_ObjCSynthesizeDecl".enum("An Objective-C @ synthesize definition."),
"Cursor_ObjCDynamicDecl".enum("An Objective-C @ dynamic definition."),
"Cursor_CXXAccessSpecifier".enum("An access specifier."),
"Cursor_FirstDecl".enum("An access specifier.", "CXCursor_UnexposedDecl"),
"Cursor_LastDecl".enum("An access specifier.", "CXCursor_CXXAccessSpecifier"),
"Cursor_FirstRef".enum("Decl references", "40"),
"Cursor_ObjCSuperClassRef".enum("", "40"),
"Cursor_ObjCProtocolRef".enum,
"Cursor_ObjCClassRef".enum,
"Cursor_TypeRef".enum(
"""
A reference to a type declaration.
A type reference occurs anywhere where a type is named but not declared. For example, given:
${codeBlock("""
typedef unsigned size_type;
size_type size;""")}
The typedef is a declaration of size_type (CXCursor_TypedefDecl), while the type of the variable "size" is referenced. The cursor referenced by the
type of size is the typedef for size_type.
"""
),
"Cursor_CXXBaseSpecifier".enum(
"""
A reference to a type declaration.
A type reference occurs anywhere where a type is named but not declared. For example, given:
${codeBlock("""
typedef unsigned size_type;
size_type size;""")}
The typedef is a declaration of size_type (CXCursor_TypedefDecl), while the type of the variable "size" is referenced. The cursor referenced by the
type of size is the typedef for size_type.
"""
),
"Cursor_TemplateRef".enum(
"A reference to a class template, function template, template template parameter, or class template partial specialization."
),
"Cursor_NamespaceRef".enum("A reference to a namespace or namespace alias."),
"Cursor_MemberRef".enum(
"A reference to a member of a struct, union, or class that occurs in some non-expression context, e.g., a designated initializer."
),
"Cursor_LabelRef".enum(
"""
A reference to a labeled statement.
This cursor kind is used to describe the jump to "start_over" in the goto statement in the following example:
${codeBlock("""
start_over:
++counter;
goto start_over;""")}
A label reference cursor refers to a label statement.
"""
),
"Cursor_OverloadedDeclRef".enum(
"""
A reference to a set of overloaded functions or function templates that has not yet been resolved to a specific function or function template.
An overloaded declaration reference cursor occurs in C++ templates where a dependent name refers to a function. For example:
${codeBlock("""
template<typename T> void swap(T&, T&);
struct X { ... };
void swap(X&, X&);
template<typename T>
void reverse(T* first, T* last) {
while (first < last - 1) {
swap(*first, *--last);
++first;
}
}
struct Y { };
void swap(Y&, Y&);""")}
Here, the identifier "swap" is associated with an overloaded declaration reference. In the template definition, "swap" refers to either of the two
"swap" functions declared above, so both results will be available. At instantiation time, "swap" may also refer to other functions found via
argument-dependent lookup (e.g., the "swap" function at the end of the example).
The functions {@code clang_getNumOverloadedDecls()} and {@code clang_getOverloadedDecl()} can be used to retrieve the definitions referenced by
this cursor.
"""
),
"Cursor_VariableRef".enum("A reference to a variable that occurs in some non-expression context, e.g., a C++ lambda capture list."),
"Cursor_LastRef".enum(
"A reference to a variable that occurs in some non-expression context, e.g., a C++ lambda capture list.",
"CXCursor_VariableRef"
),
"Cursor_FirstInvalid".enum("Error conditions", "70"),
"Cursor_InvalidFile".enum("Error conditions", "70"),
"Cursor_NoDeclFound".enum("Error conditions"),
"Cursor_NotImplemented".enum("Error conditions"),
"Cursor_InvalidCode".enum("Error conditions"),
"Cursor_LastInvalid".enum("Error conditions", "CXCursor_InvalidCode"),
"Cursor_FirstExpr".enum("Expressions", "100"),
"Cursor_UnexposedExpr".enum(
"""
An expression whose specific kind is not exposed via this interface.
Unexposed expressions have the same operations as any other kind of expression; one can extract their location information, spelling, children,
etc. However, the specific kind of the expression is not reported.
""",
"100"
),
"Cursor_DeclRefExpr".enum("An expression that refers to some value declaration, such as a function, variable, or enumerator."),
"Cursor_MemberRefExpr".enum("An expression that refers to a member of a struct, union, class, Objective-C class, etc."),
"Cursor_CallExpr".enum("An expression that calls a function."),
"Cursor_ObjCMessageExpr".enum("An expression that sends a message to an Objective-C object or class."),
"Cursor_BlockExpr".enum("An expression that represents a block literal."),
"Cursor_IntegerLiteral".enum("An integer literal."),
"Cursor_FloatingLiteral".enum("A floating point number literal."),
"Cursor_ImaginaryLiteral".enum("An imaginary number literal."),
"Cursor_StringLiteral".enum("A string literal."),
"Cursor_CharacterLiteral".enum("A character literal."),
"Cursor_ParenExpr".enum(
"""
A parenthesized expression, e.g. "(1)".
This AST node is only formed if full location information is requested.
"""
),
"Cursor_UnaryOperator".enum("This represents the unary-expression's (except sizeof and alignof)."),
"Cursor_ArraySubscriptExpr".enum("[C99 6.5.2.1] Array Subscripting."),
"Cursor_BinaryOperator".enum("A builtin binary operation expression such as \"x + y\" or \"x <= y\"."),
"Cursor_CompoundAssignOperator".enum("Compound assignment such as \"+=\"."),
"Cursor_ConditionalOperator".enum("The ?: ternary operator."),
"Cursor_CStyleCastExpr".enum(
"""
An explicit cast in C (C99 6.5.4) or a C-style cast in C++ (C++ [expr.cast]), which uses the syntax (Type)expr.
For example: (int)f.
"""
),
"Cursor_CompoundLiteralExpr".enum("[C99 6.5.2.5]"),
"Cursor_InitListExpr".enum("Describes an C or C++ initializer list."),
"Cursor_AddrLabelExpr".enum("The GNU address of label extension, representing {@code &&label}."),
"Cursor_StmtExpr".enum("This is the GNU Statement Expression extension: ({int X=4; X;})"),
"Cursor_GenericSelectionExpr".enum("Represents a C11 generic selection."),
"Cursor_GNUNullExpr".enum(
"""
Implements the GNU __null extension, which is a name for a null pointer constant that has integral type (e.g., int or long) and is the same size
and alignment as a pointer.
The __null extension is typically only used by system headers, which define #NULL as __null in C++ rather than using 0 (which is an integer that
may not match the size of a pointer).
"""
),
"Cursor_CXXStaticCastExpr".enum("C++'s static_cast <> expression."),
"Cursor_CXXDynamicCastExpr".enum("C++'s dynamic_cast <> expression."),
"Cursor_CXXReinterpretCastExpr".enum("C++'s reinterpret_cast <> expression."),
"Cursor_CXXConstCastExpr".enum("C++'s const_cast <> expression."),
"Cursor_CXXFunctionalCastExpr".enum(
"""
Represents an explicit C++ type conversion that uses "functional" notion (C++ [expr.type.conv]).
Example:
${codeBlock("""
x = int(0.5);""")}
"""
),
"Cursor_CXXTypeidExpr".enum("A C++ typeid expression (C++ [expr.typeid])."),
"Cursor_CXXBoolLiteralExpr".enum("[C++ 2.13.5] C++ Boolean Literal."),
"Cursor_CXXNullPtrLiteralExpr".enum("[C++0x 2.14.7] C++ Pointer Literal."),
"Cursor_CXXThisExpr".enum("Represents the \"this\" expression in C++"),
"Cursor_CXXThrowExpr".enum(
"""
[C++ 15] C++ Throw Expression.
This handles 'throw' and 'throw' assignment-expression. When assignment-expression isn't present, Op will be null.
"""
),
"Cursor_CXXNewExpr".enum("A new expression for memory allocation and constructor calls, e.g: \"new CXXNewExpr(foo)\"."),
"Cursor_CXXDeleteExpr".enum("A delete expression for memory deallocation and destructor calls, e.g. \"delete[] pArray\"."),
"Cursor_UnaryExpr".enum("A unary expression. (noexcept, sizeof, or other traits)"),
"Cursor_ObjCStringLiteral".enum("An Objective-C string literal i.e. \" foo\"."),
"Cursor_ObjCEncodeExpr".enum("An Objective-C @ encode expression."),
"Cursor_ObjCSelectorExpr".enum("An Objective-C @ selector expression."),
"Cursor_ObjCProtocolExpr".enum("An Objective-C @ protocol expression."),
"Cursor_ObjCBridgedCastExpr".enum(
"""
An Objective-C "bridged" cast expression, which casts between Objective-C pointers and C pointers, transferring ownership in the process.
${codeBlock("""
NSString *str = (__bridge_transfer NSString *)CFCreateString();""")}
"""
),
"Cursor_PackExpansionExpr".enum(
"""
Represents a C++0x pack expansion that produces a sequence of expressions.
A pack expansion expression contains a pattern (which itself is an expression) followed by an ellipsis. For example:
${codeBlock("""
template<typename F, typename ...Types>
void forward(F f, Types &&...args) {
f(static_cast<Types&&>(args)...);
}""")}
"""
),
"Cursor_SizeOfPackExpr".enum(
"""
Represents an expression that computes the length of a parameter pack.
${codeBlock("""
template<typename ...Types>
struct count {
static const unsigned value = sizeof...(Types);
};""")}
"""
),
"Cursor_LambdaExpr".enum(
"""
Represents a C++ lambda expression that produces a local function object.
${codeBlock("""
void abssort(float *x, unsigned N) {
std::sort(x, x + N,
[](float a, float b) {
return std::abs(a) < std::abs(b);
});
}""")}
"""
),
"Cursor_ObjCBoolLiteralExpr".enum("Objective-c Boolean Literal."),
"Cursor_ObjCSelfExpr".enum("Represents the \"self\" expression in an Objective-C method."),
"Cursor_OMPArraySectionExpr".enum("OpenMP 5.0 [2.1.5, Array Section]."),
"Cursor_ObjCAvailabilityCheckExpr".enum("Represents an {@code @available (...)} check."),
"Cursor_FixedPointLiteral".enum("Fixed point literal"),
"Cursor_OMPArrayShapingExpr".enum("OpenMP 5.0 [2.1.4, Array Shaping]."),
"Cursor_OMPIteratorExpr".enum("OpenMP 5.0 [2.1.6 Iterators]"),
"Cursor_CXXAddrspaceCastExpr".enum("OpenCL's {@code addrspace_cast<>} expression."),
"Cursor_LastExpr".enum("", "CXCursor_CXXAddrspaceCastExpr"),
"Cursor_FirstStmt".enum("Statements", "200"),
"Cursor_UnexposedStmt".enum(
"""
A statement whose specific kind is not exposed via this interface.
Unexposed statements have the same operations as any other kind of statement; one can extract their location information, spelling, children, etc.
However, the specific kind of the statement is not reported.
""",
"200"
),
"Cursor_LabelStmt".enum(
"""
A labelled statement in a function.
This cursor kind is used to describe the "start_over:" label statement in the following example:
${codeBlock("""
start_over:
++counter;""")}
"""
),
"Cursor_CompoundStmt".enum(
"""
A group of statements like { stmt stmt }.
This cursor kind is used to describe compound statements, e.g. function bodies.
"""
),
"Cursor_CaseStmt".enum("A case statement."),
"Cursor_DefaultStmt".enum("A default statement."),
"Cursor_IfStmt".enum("An if statement"),
"Cursor_SwitchStmt".enum("A switch statement."),
"Cursor_WhileStmt".enum("A while statement."),
"Cursor_DoStmt".enum("A do statement."),
"Cursor_ForStmt".enum("A for statement."),
"Cursor_GotoStmt".enum("A goto statement."),
"Cursor_IndirectGotoStmt".enum("An indirect goto statement."),
"Cursor_ContinueStmt".enum("A continue statement."),
"Cursor_BreakStmt".enum("A break statement."),
"Cursor_ReturnStmt".enum("A return statement."),
"Cursor_GCCAsmStmt".enum("A GCC inline assembly statement extension."),
"Cursor_AsmStmt".enum("A GCC inline assembly statement extension.", "CXCursor_GCCAsmStmt"),
"Cursor_ObjCAtTryStmt".enum("Objective-C's overall @ try- @ catch- @ finally statement.", "216"),
"Cursor_ObjCAtCatchStmt".enum("Objective-C's @ catch statement."),
"Cursor_ObjCAtFinallyStmt".enum("Objective-C's @ finally statement."),
"Cursor_ObjCAtThrowStmt".enum("Objective-C's @ throw statement."),
"Cursor_ObjCAtSynchronizedStmt".enum("Objective-C's @ synchronized statement."),
"Cursor_ObjCAutoreleasePoolStmt".enum("Objective-C's autorelease pool statement."),
"Cursor_ObjCForCollectionStmt".enum("Objective-C's collection statement."),
"Cursor_CXXCatchStmt".enum("C++'s catch statement."),
"Cursor_CXXTryStmt".enum("C++'s try statement."),
"Cursor_CXXForRangeStmt".enum("C++'s for (* : *) statement."),
"Cursor_SEHTryStmt".enum("Windows Structured Exception Handling's try statement."),
"Cursor_SEHExceptStmt".enum("Windows Structured Exception Handling's except statement."),
"Cursor_SEHFinallyStmt".enum("Windows Structured Exception Handling's finally statement."),
"Cursor_MSAsmStmt".enum("A MS inline assembly statement extension."),
"Cursor_NullStmt".enum(
"""
The null statement ";": C99 6.8.3p3.
This cursor kind is used to describe the null statement.
"""
),
"Cursor_DeclStmt".enum("Adaptor class for mixing declarations with statements and expressions."),
"Cursor_OMPParallelDirective".enum("OpenMP parallel directive."),
"Cursor_OMPSimdDirective".enum("OpenMP SIMD directive."),
"Cursor_OMPForDirective".enum("OpenMP for directive."),
"Cursor_OMPSectionsDirective".enum("OpenMP sections directive."),
"Cursor_OMPSectionDirective".enum("OpenMP section directive."),
"Cursor_OMPSingleDirective".enum("OpenMP single directive."),
"Cursor_OMPParallelForDirective".enum("OpenMP parallel for directive."),
"Cursor_OMPParallelSectionsDirective".enum("OpenMP parallel sections directive."),
"Cursor_OMPTaskDirective".enum("OpenMP task directive."),
"Cursor_OMPMasterDirective".enum("OpenMP master directive."),
"Cursor_OMPCriticalDirective".enum("OpenMP critical directive."),
"Cursor_OMPTaskyieldDirective".enum("OpenMP taskyield directive."),
"Cursor_OMPBarrierDirective".enum("OpenMP barrier directive."),
"Cursor_OMPTaskwaitDirective".enum("OpenMP taskwait directive."),
"Cursor_OMPFlushDirective".enum("OpenMP flush directive."),
"Cursor_SEHLeaveStmt".enum("Windows Structured Exception Handling's leave statement."),
"Cursor_OMPOrderedDirective".enum("OpenMP ordered directive."),
"Cursor_OMPAtomicDirective".enum("OpenMP atomic directive."),
"Cursor_OMPForSimdDirective".enum("OpenMP for SIMD directive."),
"Cursor_OMPParallelForSimdDirective".enum("OpenMP parallel for SIMD directive."),
"Cursor_OMPTargetDirective".enum("OpenMP target directive."),
"Cursor_OMPTeamsDirective".enum("OpenMP teams directive."),
"Cursor_OMPTaskgroupDirective".enum("OpenMP taskgroup directive."),
"Cursor_OMPCancellationPointDirective".enum("OpenMP cancellation point directive."),
"Cursor_OMPCancelDirective".enum("OpenMP cancel directive."),
"Cursor_OMPTargetDataDirective".enum("OpenMP target data directive."),
"Cursor_OMPTaskLoopDirective".enum("OpenMP taskloop directive."),
"Cursor_OMPTaskLoopSimdDirective".enum("OpenMP taskloop simd directive."),
"Cursor_OMPDistributeDirective".enum("OpenMP distribute directive."),
"Cursor_OMPTargetEnterDataDirective".enum("OpenMP target enter data directive."),
"Cursor_OMPTargetExitDataDirective".enum("OpenMP target exit data directive."),
"Cursor_OMPTargetParallelDirective".enum("OpenMP target parallel directive."),
"Cursor_OMPTargetParallelForDirective".enum("OpenMP target parallel for directive."),
"Cursor_OMPTargetUpdateDirective".enum("OpenMP target update directive."),
"Cursor_OMPDistributeParallelForDirective".enum("OpenMP distribute parallel for directive."),
"Cursor_OMPDistributeParallelForSimdDirective".enum("OpenMP distribute parallel for simd directive."),
"Cursor_OMPDistributeSimdDirective".enum("OpenMP distribute simd directive."),
"Cursor_OMPTargetParallelForSimdDirective".enum("OpenMP target parallel for simd directive."),
"Cursor_OMPTargetSimdDirective".enum("OpenMP target simd directive."),
"Cursor_OMPTeamsDistributeDirective".enum("OpenMP teams distribute directive."),
"Cursor_OMPTeamsDistributeSimdDirective".enum("OpenMP teams distribute simd directive."),
"Cursor_OMPTeamsDistributeParallelForSimdDirective".enum("OpenMP teams distribute parallel for simd directive."),
"Cursor_OMPTeamsDistributeParallelForDirective".enum("OpenMP teams distribute parallel for directive."),
"Cursor_OMPTargetTeamsDirective".enum("OpenMP target teams directive."),
"Cursor_OMPTargetTeamsDistributeDirective".enum("OpenMP target teams distribute directive."),
"Cursor_OMPTargetTeamsDistributeParallelForDirective".enum("OpenMP target teams distribute parallel for directive."),
"Cursor_OMPTargetTeamsDistributeParallelForSimdDirective".enum("OpenMP target teams distribute parallel for simd directive."),
"Cursor_OMPTargetTeamsDistributeSimdDirective".enum("OpenMP target teams distribute simd directive."),
"Cursor_BuiltinBitCastExpr".enum("C++2a std::bit_cast expression."),
"Cursor_OMPMasterTaskLoopDirective".enum("OpenMP master taskloop directive."),
"Cursor_OMPParallelMasterTaskLoopDirective".enum("OpenMP parallel master taskloop directive."),
"Cursor_OMPMasterTaskLoopSimdDirective".enum("OpenMP master taskloop simd directive."),
"Cursor_OMPParallelMasterTaskLoopSimdDirective".enum("OpenMP parallel master taskloop simd directive."),
"Cursor_OMPParallelMasterDirective".enum("OpenMP parallel master directive."),
"Cursor_OMPDepobjDirective".enum("OpenMP depobj directive."),
"Cursor_OMPScanDirective".enum("OpenMP scan directive."),
"Cursor_OMPTileDirective".enum("OpenMP tile directive."),
"Cursor_OMPCanonicalLoop".enum("OpenMP canonical loop."),
"Cursor_OMPInteropDirective".enum("OpenMP interop directive."),
"Cursor_OMPDispatchDirective".enum("OpenMP dispatch directive."),
"Cursor_OMPMaskedDirective".enum("OpenMP masked directive."),
"Cursor_OMPUnrollDirective".enum("OpenMP unroll directive."),
"Cursor_LastStmt".enum("", "CXCursor_OMPUnrollDirective"),
"Cursor_TranslationUnit".enum(
"""
Cursor that represents the translation unit itself.
The translation unit cursor exists primarily to act as the root cursor for traversing the contents of a translation unit.
""",
"300"
),
"Cursor_FirstAttr".enum("Attributes", "400"),
"Cursor_UnexposedAttr".enum("An attribute whose specific kind is not exposed via this interface.", "400"),
"Cursor_IBActionAttr".enum(""),
"Cursor_IBOutletAttr".enum(""),
"Cursor_IBOutletCollectionAttr".enum(""),
"Cursor_CXXFinalAttr".enum(""),
"Cursor_CXXOverrideAttr".enum(""),
"Cursor_AnnotateAttr".enum(""),
"Cursor_AsmLabelAttr".enum(""),
"Cursor_PackedAttr".enum(""),
"Cursor_PureAttr".enum(""),
"Cursor_ConstAttr".enum(""),
"Cursor_NoDuplicateAttr".enum(""),
"Cursor_CUDAConstantAttr".enum(""),
"Cursor_CUDADeviceAttr".enum(""),
"Cursor_CUDAGlobalAttr".enum(""),
"Cursor_CUDAHostAttr".enum(""),
"Cursor_CUDASharedAttr".enum(""),
"Cursor_VisibilityAttr".enum(""),
"Cursor_DLLExport".enum(""),
"Cursor_DLLImport".enum(""),
"Cursor_NSReturnsRetained".enum(""),
"Cursor_NSReturnsNotRetained".enum(""),
"Cursor_NSReturnsAutoreleased".enum(""),
"Cursor_NSConsumesSelf".enum(""),
"Cursor_NSConsumed".enum(""),
"Cursor_ObjCException".enum(""),
"Cursor_ObjCNSObject".enum(""),
"Cursor_ObjCIndependentClass".enum(""),
"Cursor_ObjCPreciseLifetime".enum(""),
"Cursor_ObjCReturnsInnerPointer".enum(""),
"Cursor_ObjCRequiresSuper".enum(""),
"Cursor_ObjCRootClass".enum(""),
"Cursor_ObjCSubclassingRestricted".enum(""),
"Cursor_ObjCExplicitProtocolImpl".enum(""),
"Cursor_ObjCDesignatedInitializer".enum(""),
"Cursor_ObjCRuntimeVisible".enum(""),
"Cursor_ObjCBoxable".enum(""),
"Cursor_FlagEnum".enum(""),
"Cursor_ConvergentAttr".enum(""),
"Cursor_WarnUnusedAttr".enum(""),
"Cursor_WarnUnusedResultAttr".enum(""),
"Cursor_AlignedAttr".enum(""),
"Cursor_LastAttr".enum("", "CXCursor_AlignedAttr"),
"Cursor_PreprocessingDirective".enum("Preprocessing", "500"),
"Cursor_MacroDefinition".enum(""),
"Cursor_MacroExpansion".enum(""),
"Cursor_MacroInstantiation".enum("", "CXCursor_MacroExpansion"),
"Cursor_InclusionDirective".enum("", "503"),
"Cursor_FirstPreprocessing".enum("", "CXCursor_PreprocessingDirective"),
"Cursor_LastPreprocessing".enum("", "CXCursor_InclusionDirective"),
"Cursor_ModuleImportDecl".enum("A module import declaration.", "600"),
"Cursor_TypeAliasTemplateDecl".enum(""),
"Cursor_StaticAssert".enum("A static_assert or _Static_assert node"),
"Cursor_FriendDecl".enum("a friend declaration."),
"Cursor_FirstExtraDecl".enum("", "CXCursor_ModuleImportDecl"),
"Cursor_LastExtraDecl".enum("", "CXCursor_FriendDecl"),
"Cursor_OverloadCandidate".enum("A code completion overload candidate.", "700")
)
EnumConstant(
"""
Describe the linkage of the entity referred to by a cursor.
({@code enum CXLinkageKind})
""",
"Linkage_Invalid".enum("This value indicates that no linkage information is available for a provided CXCursor.", "0"),
"Linkage_NoLinkage".enum(
"This is the linkage for variables, parameters, and so on that have automatic storage. This covers normal (non-extern) local variables."
),
"Linkage_Internal".enum("This is the linkage for static variables and static functions."),
"Linkage_UniqueExternal".enum("This is the linkage for entities with external linkage that live in C++ anonymous namespaces."),
"Linkage_External".enum("This is the linkage for entities with true, external linkage.")
)
EnumConstant(
"{@code enum CXVisibilityKind}",
"Visibility_Invalid".enum("This value indicates that no visibility information is available for a provided CXCursor.", "0"),
"Visibility_Hidden".enum("Symbol not seen by the linker."),
"Visibility_Protected".enum("Symbol seen by the linker but resolves to a symbol inside this object."),
"Visibility_Default".enum("Symbol seen by the linker and acts like a normal symbol.")
)
EnumConstant(
"""
Describe the "language" of the entity referred to by a cursor.
({@code enum CXLanguageKind})
""",
"Language_Invalid".enum("", "0"),
"Language_C".enum,
"Language_ObjC".enum,
"Language_CPlusPlus".enum
)
EnumConstant(
"""
Describe the "thread-local storage (TLS) kind" of the declaration referred to by a cursor.
({@code enum CXTLSKind})
""",
"TLS_None".enum("", "0"),
"TLS_Dynamic".enum,
"TLS_Static".enum
)
EnumConstant(
"""
Describes the kind of type
({@code enum CXTypeKind})
""",
"Type_Invalid".enum("Represents an invalid type (e.g., where no type is available).", "0"),
"Type_Unexposed".enum("A type whose specific kind is not exposed via this interface."),
"Type_Void".enum(""),
"Type_Bool".enum(""),
"Type_Char_U".enum(""),
"Type_UChar".enum(""),
"Type_Char16".enum(""),
"Type_Char32".enum(""),
"Type_UShort".enum(""),
"Type_UInt".enum(""),
"Type_ULong".enum(""),
"Type_ULongLong".enum(""),
"Type_UInt128".enum(""),
"Type_Char_S".enum(""),
"Type_SChar".enum(""),
"Type_WChar".enum(""),
"Type_Short".enum(""),
"Type_Int".enum(""),
"Type_Long".enum(""),
"Type_LongLong".enum(""),
"Type_Int128".enum(""),
"Type_Float".enum(""),
"Type_Double".enum(""),
"Type_LongDouble".enum(""),
"Type_NullPtr".enum(""),
"Type_Overload".enum(""),
"Type_Dependent".enum(""),
"Type_ObjCId".enum(""),
"Type_ObjCClass".enum(""),
"Type_ObjCSel".enum(""),
"Type_Float128".enum(""),
"Type_Half".enum(""),
"Type_Float16".enum(""),
"Type_ShortAccum".enum(""),
"Type_Accum".enum(""),
"Type_LongAccum".enum(""),
"Type_UShortAccum".enum(""),
"Type_UAccum".enum(""),
"Type_ULongAccum".enum(""),
"Type_BFloat16".enum(""),
"Type_FirstBuiltin".enum("", "CXType_Void"),
"Type_LastBuiltin".enum("", "CXType_BFloat16"),
"Type_Complex".enum("", "100"),
"Type_Pointer".enum(""),
"Type_BlockPointer".enum(""),
"Type_LValueReference".enum(""),
"Type_RValueReference".enum(""),
"Type_Record".enum(""),
"Type_Enum".enum(""),
"Type_Typedef".enum(""),
"Type_ObjCInterface".enum(""),
"Type_ObjCObjectPointer".enum(""),
"Type_FunctionNoProto".enum(""),
"Type_FunctionProto".enum(""),
"Type_ConstantArray".enum(""),
"Type_Vector".enum(""),
"Type_IncompleteArray".enum(""),
"Type_VariableArray".enum(""),
"Type_DependentSizedArray".enum(""),
"Type_MemberPointer".enum(""),
"Type_Auto".enum(""),
"Type_Elaborated".enum(
"""
Represents a type that was referred to using an elaborated type keyword.
E.g., struct S, or via a qualified name, e.g., N::M::type, or both.
"""
),
"Type_Pipe".enum("OpenCL PipeType."),
"Type_OCLImage1dRO".enum(""),
"Type_OCLImage1dArrayRO".enum(""),
"Type_OCLImage1dBufferRO".enum(""),
"Type_OCLImage2dRO".enum(""),
"Type_OCLImage2dArrayRO".enum(""),
"Type_OCLImage2dDepthRO".enum(""),
"Type_OCLImage2dArrayDepthRO".enum(""),
"Type_OCLImage2dMSAARO".enum(""),
"Type_OCLImage2dArrayMSAARO".enum(""),
"Type_OCLImage2dMSAADepthRO".enum(""),
"Type_OCLImage2dArrayMSAADepthRO".enum(""),
"Type_OCLImage3dRO".enum(""),
"Type_OCLImage1dWO".enum(""),
"Type_OCLImage1dArrayWO".enum(""),
"Type_OCLImage1dBufferWO".enum(""),
"Type_OCLImage2dWO".enum(""),
"Type_OCLImage2dArrayWO".enum(""),
"Type_OCLImage2dDepthWO".enum(""),
"Type_OCLImage2dArrayDepthWO".enum(""),
"Type_OCLImage2dMSAAWO".enum(""),
"Type_OCLImage2dArrayMSAAWO".enum(""),
"Type_OCLImage2dMSAADepthWO".enum(""),
"Type_OCLImage2dArrayMSAADepthWO".enum(""),
"Type_OCLImage3dWO".enum(""),
"Type_OCLImage1dRW".enum(""),
"Type_OCLImage1dArrayRW".enum(""),
"Type_OCLImage1dBufferRW".enum(""),
"Type_OCLImage2dRW".enum(""),
"Type_OCLImage2dArrayRW".enum(""),
"Type_OCLImage2dDepthRW".enum(""),
"Type_OCLImage2dArrayDepthRW".enum(""),
"Type_OCLImage2dMSAARW".enum(""),
"Type_OCLImage2dArrayMSAARW".enum(""),
"Type_OCLImage2dMSAADepthRW".enum(""),
"Type_OCLImage2dArrayMSAADepthRW".enum(""),
"Type_OCLImage3dRW".enum(""),
"Type_OCLSampler".enum(""),
"Type_OCLEvent".enum(""),
"Type_OCLQueue".enum(""),
"Type_OCLReserveID".enum(""),
"Type_ObjCObject".enum,
"Type_ObjCTypeParam".enum,
"Type_Attributed".enum,
"Type_OCLIntelSubgroupAVCMcePayload".enum(""),
"Type_OCLIntelSubgroupAVCImePayload".enum(""),
"Type_OCLIntelSubgroupAVCRefPayload".enum(""),
"Type_OCLIntelSubgroupAVCSicPayload".enum(""),
"Type_OCLIntelSubgroupAVCMceResult".enum(""),
"Type_OCLIntelSubgroupAVCImeResult".enum(""),
"Type_OCLIntelSubgroupAVCRefResult".enum(""),
"Type_OCLIntelSubgroupAVCSicResult".enum(""),
"Type_OCLIntelSubgroupAVCImeResultSingleRefStreamout".enum(""),
"Type_OCLIntelSubgroupAVCImeResultDualRefStreamout".enum(""),
"Type_OCLIntelSubgroupAVCImeSingleRefStreamin".enum(""),
"Type_OCLIntelSubgroupAVCImeDualRefStreamin".enum(""),
"Type_ExtVector".enum(""),
"Type_Atomic".enum("")
)
EnumConstant(
"""
Describes the calling convention of a function type
({@code enum CXCallingConv})
""",
"CallingConv_Default".enum("", "0"),
"CallingConv_C".enum,
"CallingConv_X86StdCall".enum,
"CallingConv_X86FastCall".enum,
"CallingConv_X86ThisCall".enum,
"CallingConv_X86Pascal".enum,
"CallingConv_AAPCS".enum,
"CallingConv_AAPCS_VFP".enum,
"CallingConv_X86RegCall".enum,
"CallingConv_IntelOclBicc".enum,
"CallingConv_Win64".enum,
"CallingConv_X86_64Win64".enum("Alias for compatibility with older versions of API.", "CXCallingConv_Win64"),
"CallingConv_X86_64SysV".enum("", "11"),
"CallingConv_X86VectorCall".enum(""),
"CallingConv_Swift".enum(""),
"CallingConv_PreserveMost".enum(""),
"CallingConv_PreserveAll".enum(""),
"CallingConv_AArch64VectorCall".enum(""),
"CallingConv_SwiftAsync".enum(""),
"CallingConv_Invalid".enum("", "100"),
"CallingConv_Unexposed".enum("", "200")
)
EnumConstant(
"""
Describes the kind of a template argument. ({@code enum CXTemplateArgumentKind})
See the definition of llvm::clang::TemplateArgument::ArgKind for full element descriptions.
""",
"TemplateArgumentKind_Null".enum("", "0"),
"TemplateArgumentKind_Type".enum,
"TemplateArgumentKind_Declaration".enum,
"TemplateArgumentKind_NullPtr".enum,
"TemplateArgumentKind_Integral".enum,
"TemplateArgumentKind_Template".enum,
"TemplateArgumentKind_TemplateExpansion".enum,
"TemplateArgumentKind_Expression".enum,
"TemplateArgumentKind_Pack".enum,
"TemplateArgumentKind_Invalid".enum("Indicates an error case, preventing the kind from being deduced.")
)
EnumConstant(
"{@code enum CXTypeNullabilityKind}",
"TypeNullability_NonNull".enum("Values of this type can never be null.", "0"),
"TypeNullability_Nullable".enum("Values of this type can be null."),
"TypeNullability_Unspecified".enum(
"""
Whether values of this type can be null is (explicitly) unspecified. This captures a (fairly rare) case where we can't conclude anything about the
nullability of the type even though it has been considered.
"""
),
"TypeNullability_Invalid".enum("Nullability is not applicable to this type."),
"TypeNullability_NullableResult".enum(
"""
Generally behaves like {@code Nullable}, except when used in a block parameter that was imported into a swift async method. There, swift will
assume that the parameter can get null even if no error occured. {@code _Nullable} parameters are assumed to only get null on error.
"""
)
)
EnumConstant(
"""
List the possible error codes for {@code clang_Type_getSizeOf}, {@code clang_Type_getAlignOf}, {@code clang_Type_getOffsetOf} and {@code
clang_Cursor_getOffsetOf}. ({@code enum CXTypeLayoutError})
A value of this enumeration type can be returned if the target type is not a valid argument to sizeof, alignof or offsetof.
""",
"TypeLayoutError_Invalid".enum("Type is of kind CXType_Invalid.", "-1"),
"TypeLayoutError_Incomplete".enum("The type is an incomplete Type.", "-2"),
"TypeLayoutError_Dependent".enum("The type is a dependent Type.", "-3"),
"TypeLayoutError_NotConstantSize".enum("The type is not a constant size type.", "-4"),
"TypeLayoutError_InvalidFieldName".enum("The Field name is not valid for this record.", "-5"),
"TypeLayoutError_Undeduced".enum("The type is undeduced.", "-6")
)
EnumConstant(
"{@code enum CXRefQualifierKind}",
"RefQualifier_None".enum("No ref-qualifier was provided.", "0"),
"RefQualifier_LValue".enum("An lvalue ref-qualifier was provided ({@code &})."),
"RefQualifier_RValue".enum("An rvalue ref-qualifier was provided ({@code &&}).")
)
EnumConstant(
"""
Represents the C++ access control level to a base class for a cursor with kind CX_CXXBaseSpecifier.
({@code enum CX_CXXAccessSpecifier})
""",
"_CXXInvalidAccessSpecifier".enum("", "0"),
"_CXXPublic".enum,
"_CXXProtected".enum,
"_CXXPrivate".enum
)
EnumConstant(
"""
Represents the storage classes as declared in the source. CX_SC_Invalid was added for the case that the passed cursor in not a declaration.
({@code enum CX_StorageClass})
""",
"_SC_Invalid".enum("", "0"),
"_SC_None".enum,
"_SC_Extern".enum,
"_SC_Static".enum,
"_SC_PrivateExtern".enum,
"_SC_OpenCLWorkGroupLocal".enum,
"_SC_Auto".enum,
"_SC_Register".enum
)
EnumConstant(
"""
Describes how the traversal of the children of a particular cursor should proceed after visiting a particular child cursor. ({@code enum
CXChildVisitResult})
A value of this enumeration type should be returned by each {@code CXCursorVisitor} to indicate how #visitChildren() proceed.
""",
"ChildVisit_Break".enum("Terminates the cursor traversal.", "0"),
"ChildVisit_Continue".enum("Continues the cursor traversal with the next sibling of the cursor just visited, without visiting its children."),
"ChildVisit_Recurse".enum("Recursively traverse the children of this cursor, using the same visitor and client data.")
)
EnumConstant(
"""
Properties for the printing policy. ({@code enum CXPrintingPolicyProperty})
See {@code clang::PrintingPolicy} for more information.
""",
"PrintingPolicy_Indentation".enum("", "0"),
"PrintingPolicy_SuppressSpecifiers".enum,
"PrintingPolicy_SuppressTagKeyword".enum,
"PrintingPolicy_IncludeTagDefinition".enum,
"PrintingPolicy_SuppressScope".enum,
"PrintingPolicy_SuppressUnwrittenScope".enum,
"PrintingPolicy_SuppressInitializers".enum,
"PrintingPolicy_ConstantArraySizeAsWritten".enum,
"PrintingPolicy_AnonymousTagLocations".enum,
"PrintingPolicy_SuppressStrongLifetime".enum,
"PrintingPolicy_SuppressLifetimeQualifiers".enum,
"PrintingPolicy_SuppressTemplateArgsInCXXConstructors".enum,
"PrintingPolicy_Bool".enum,
"PrintingPolicy_Restrict".enum,
"PrintingPolicy_Alignof".enum,
"PrintingPolicy_UnderscoreAlignof".enum,
"PrintingPolicy_UseVoidForZeroParams".enum,
"PrintingPolicy_TerseOutput".enum,
"PrintingPolicy_PolishForDeclaration".enum,
"PrintingPolicy_Half".enum,
"PrintingPolicy_MSWChar".enum,
"PrintingPolicy_IncludeNewlines".enum,
"PrintingPolicy_MSVCFormatting".enum,
"PrintingPolicy_ConstantsAsWritten".enum,
"PrintingPolicy_SuppressImplicitBase".enum,
"PrintingPolicy_FullyQualifiedName".enum,
"PrintingPolicy_LastProperty".enum("", "CXPrintingPolicy_FullyQualifiedName")
)
EnumConstant(
"""
Property attributes for a {@code CXCursor_ObjCPropertyDecl}.
({@code CXObjCPropertyAttrKind})
""",
"ObjCPropertyAttr_noattr".enum("", "0x00"),
"ObjCPropertyAttr_readonly".enum("", "0x01"),
"ObjCPropertyAttr_getter".enum("", "0x02"),
"ObjCPropertyAttr_assign".enum("", "0x04"),
"ObjCPropertyAttr_readwrite".enum("", "0x08"),
"ObjCPropertyAttr_retain".enum("", "0x10"),
"ObjCPropertyAttr_copy".enum("", "0x20"),
"ObjCPropertyAttr_nonatomic".enum("", "0x40"),
"ObjCPropertyAttr_setter".enum("", "0x80"),
"ObjCPropertyAttr_atomic".enum("", "0x100"),
"ObjCPropertyAttr_weak".enum("", "0x200"),
"ObjCPropertyAttr_strong".enum("", "0x400"),
"ObjCPropertyAttr_unsafe_unretained".enum("", "0x800"),
"ObjCPropertyAttr_class".enum("", "0x1000")
)
EnumConstant(
"""
'Qualifiers' written next to the return and parameter types in Objective-C method declarations.
({@code CXObjCDeclQualifierKind})
""",
"ObjCDeclQualifier_None".enum("", "0x0"),
"ObjCDeclQualifier_In".enum("", "0x1"),
"ObjCDeclQualifier_Inout".enum("", "0x2"),
"ObjCDeclQualifier_Out".enum("", "0x4"),
"ObjCDeclQualifier_Bycopy".enum("", "0x8"),
"ObjCDeclQualifier_Byref".enum("", "0x10"),
"ObjCDeclQualifier_Oneway".enum("", "0x20")
)
EnumConstant(
"{@code enum CXNameRefFlags}",
"NameRange_WantQualifier".enum("Include the nested-name-specifier, e.g. Foo:: in x.Foo::y, in the range.", "0x1"),
"NameRange_WantTemplateArgs".enum("Include the explicit template arguments, e.g. <int> in x.f<int>, in the range.", "0x2"),
"NameRange_WantSinglePiece".enum(
"""
If the name is non-contiguous, return the full spanning range.
Non-contiguous names occur in Objective-C when a selector with two or more parameters is used, or in C++ when using an operator:
${codeBlock("""
[object doSomething:here withValue:there]; // Objective-C
return some_vector[1]; // C++""")}
""",
"0x4"
)
)
EnumConstant(
"""
Describes a kind of token.
({@code CXTokenKind})
""",
"Token_Punctuation".enum("A token that contains some kind of punctuation.", "0"),
"Token_Keyword".enum("A language keyword."),
"Token_Identifier".enum("An identifier (that is not a keyword)."),
"Token_Literal".enum("A numeric, string, or character literal."),
"Token_Comment".enum("A comment.")
)
EnumConstant(
"""
Describes a single piece of text within a code-completion string. ({@code enum CXCompletionChunkKind})
Each "chunk" within a code-completion string ({@code CXCompletionString}) is either a piece of text with a specific "kind" that describes how that text
should be interpreted by the client or is another completion string.
""",
"CompletionChunk_Optional".enum(
"""
A code-completion string that describes "optional" text that could be a part of the template (but is not required).
The Optional chunk is the only kind of chunk that has a code-completion string for its representation, which is accessible via {@code
clang_getCompletionChunkCompletionString()}. The code-completion string describes an additional part of the template that is completely optional.
For example, optional chunks can be used to describe the placeholders for arguments that match up with defaulted function parameters, e.g. given:
${codeBlock("""
void f(int x, float y = 3.14, double z = 2.71828);""")}
The code-completion string for this function would contain:
${ul(
"a TypedText chunk for \"f\".",
"a LeftParen chunk for \"(\".",
"a Placeholder chunk for \"int x\"",
"""
an Optional chunk containing the remaining defaulted arguments, e.g.,
${ul(
"a Comma chunk for \",\"",
"a Placeholder chunk for \"float y\"",
"""
an Optional chunk containing the last defaulted argument:
${ul(
"a Comma chunk for \",\"",
"a Placeholder chunk for \"double z\""
)}
"""
)}
""",
"a RightParen chunk for \")\""
)}
There are many ways to handle Optional chunks. Two simple approaches are:
${ul(
"Completely ignore optional chunks, in which case the template for the function \"f\" would only include the first parameter (\"int x\").",
"Fully expand all optional chunks, in which case the template for the function \"f\" would have all of the parameters."
)}
""",
"0"
),
"CompletionChunk_TypedText".enum(
"""
Text that a user would be expected to type to get this code-completion result.
There will be exactly one "typed text" chunk in a semantic string, which will typically provide the spelling of a keyword or the name of a
declaration that could be used at the current code point. Clients are expected to filter the code-completion results based on the text in this
chunk.
"""
),
"CompletionChunk_Text".enum(
"""
Text that should be inserted as part of a code-completion result.
A "text" chunk represents text that is part of the template to be inserted into user code should this particular code-completion result be
selected.
"""
),
"CompletionChunk_Placeholder".enum(
"""
Placeholder text that should be replaced by the user.
A "placeholder" chunk marks a place where the user should insert text into the code-completion template. For example, placeholders might mark the
function parameters for a function declaration, to indicate that the user should provide arguments for each of those parameters. The actual text in
a placeholder is a suggestion for the text to display before the user replaces the placeholder with real code.
"""
),
"CompletionChunk_Informative".enum(
"""
Informative text that should be displayed but never inserted as part of the template.
An "informative" chunk contains annotations that can be displayed to help the user decide whether a particular code-completion result is the right
option, but which is not part of the actual template to be inserted by code completion.
"""
),
"CompletionChunk_CurrentParameter".enum(
"""
Text that describes the current parameter when code-completion is referring to function call, message send, or template specialization.
A "current parameter" chunk occurs when code-completion is providing information about a parameter corresponding to the argument at the
code-completion point. For example, given a function
${codeBlock("""
int add(int x, int y);""")}
and the source code {@code add(}, where the code-completion point is after the "(", the code-completion string will contain a "current parameter"
chunk for "int x", indicating that the current argument will initialize that parameter. After typing further, to {@code add(17}, (where the
code-completion point is after the ","), the code-completion string will contain a "current parameter" chunk to "int y".
"""
),
"CompletionChunk_LeftParen".enum("A left parenthesis ('('), used to initiate a function call or signal the beginning of a function parameter list."),
"CompletionChunk_RightParen".enum("A right parenthesis (')'), used to finish a function call or signal the end of a function parameter list."),
"CompletionChunk_LeftBracket".enum("A left bracket ('[')."),
"CompletionChunk_RightBracket".enum("A right bracket (']')."),
"CompletionChunk_LeftBrace".enum("A left brace ('{')."),
"CompletionChunk_RightBrace".enum("A right brace ('}')."),
"CompletionChunk_LeftAngle".enum("A left angle bracket (' <')."),
"CompletionChunk_RightAngle".enum("A right angle bracket ('>')."),
"CompletionChunk_Comma".enum("A comma separator (',')."),
"CompletionChunk_ResultType".enum(
"""
Text that specifies the result type of a given result.
This special kind of informative chunk is not meant to be inserted into the text buffer. Rather, it is meant to illustrate the type that an
expression using the given completion string would have.
"""
),
"CompletionChunk_Colon".enum("A colon (':')."),
"CompletionChunk_SemiColon".enum("A semicolon (';')."),
"CompletionChunk_Equal".enum("An '=' sign."),
"CompletionChunk_HorizontalSpace".enum("Horizontal space (' ')."),
"CompletionChunk_VerticalSpace".enum("Vertical space ('\\n'), after which it is generally a good idea to perform indentation.")
)
EnumConstant(
"""
Flags that can be passed to {@code clang_codeCompleteAt()} to modify its behavior. ({@code enum CXCodeComplete_Flags})
The enumerators in this enumeration can be bitwise-OR'd together to provide multiple options to {@code clang_codeCompleteAt()}.
""",
"CodeComplete_IncludeMacros".enum("Whether to include macros within the set of code completions returned.", "0x01"),
"CodeComplete_IncludeCodePatterns".enum(
"Whether to include code patterns for language constructs within the set of code completions, e.g., for loops.",
"0x02"
),
"CodeComplete_IncludeBriefComments".enum("Whether to include brief documentation within the set of code completions returned.", "0x04"),
"CodeComplete_SkipPreamble".enum(
"""
Whether to speed up completion by omitting top- or namespace-level entities defined in the preamble. There's no guarantee any particular entity is
omitted. This may be useful if the headers are indexed externally.
""",
"0x08"
),
"CodeComplete_IncludeCompletionsWithFixIts".enum(
"Whether to include completions with small fix-its, e.g. change '.' to '->' on member access, etc.",
"0x10"
)
)
EnumConstant(
"""
Bits that represent the context under which completion is occurring. ({@code enum CXCompletionContext})
The enumerators in this enumeration may be bitwise-OR'd together if multiple contexts are occurring simultaneously.
""",
"CompletionContext_Unexposed".enum(
"The context for completions is unexposed, as only Clang results should be included. (This is equivalent to having no context bits set.)",
"0"
),
"CompletionContext_AnyType".enum("Completions for any possible type should be included in the results.", "1 << 0"),
"CompletionContext_AnyValue".enum("Completions for any possible value (variables, function calls, etc.) should be included in the results.", "1 << 1"),
"CompletionContext_ObjCObjectValue".enum("Completions for values that resolve to an Objective-C object should be included in the results.", "1 << 2"),
"CompletionContext_ObjCSelectorValue".enum(
"Completions for values that resolve to an Objective-C selector should be included in the results.",
"1 << 3"
),
"CompletionContext_CXXClassTypeValue".enum("Completions for values that resolve to a C++ class type should be included in the results.", "1 << 4"),
"CompletionContext_DotMemberAccess".enum(
"Completions for fields of the member being accessed using the dot operator should be included in the results.",
"1 << 5"
),
"CompletionContext_ArrowMemberAccess".enum(
"Completions for fields of the member being accessed using the arrow operator should be included in the results.",
"1 << 6"
),
"CompletionContext_ObjCPropertyAccess".enum(
"Completions for properties of the Objective-C object being accessed using the dot operator should be included in the results.",
"1 << 7"
),
"CompletionContext_EnumTag".enum("Completions for enum tags should be included in the results.", "1 << 8"),
"CompletionContext_UnionTag".enum("Completions for union tags should be included in the results.", "1 << 9"),
"CompletionContext_StructTag".enum("Completions for struct tags should be included in the results.", "1 << 10"),
"CompletionContext_ClassTag".enum("Completions for C++ class names should be included in the results.", "1 << 11"),
"CompletionContext_Namespace".enum("Completions for C++ namespaces and namespace aliases should be included in the results.", "1 << 12"),
"CompletionContext_NestedNameSpecifier".enum("Completions for C++ nested name specifiers should be included in the results.", "1 << 13"),
"CompletionContext_ObjCInterface".enum("Completions for Objective-C interfaces (classes) should be included in the results.", "1 << 14"),
"CompletionContext_ObjCProtocol".enum("Completions for Objective-C protocols should be included in the results.", "1 << 15"),
"CompletionContext_ObjCCategory".enum("Completions for Objective-C categories should be included in the results.", "1 << 16"),
"CompletionContext_ObjCInstanceMessage".enum("Completions for Objective-C instance messages should be included in the results.", "1 << 17"),
"CompletionContext_ObjCClassMessage".enum("Completions for Objective-C class messages should be included in the results.", "1 << 18"),
"CompletionContext_ObjCSelectorName".enum("Completions for Objective-C selector names should be included in the results.", "1 << 19"),
"CompletionContext_MacroName".enum("Completions for preprocessor macro names should be included in the results.", "1 << 20"),
"CompletionContext_NaturalLanguage".enum("Natural language completions should be included in the results.", "1 << 21"),
"CompletionContext_IncludedFile".enum("{@code \\#include} file completions should be included in the results.", "1 << 22"),
"CompletionContext_Unknown".enum("The current context is unknown, so set all contexts.", "((1 << 23) - 1)")
)
EnumConstant(
"{@code CXEvalResultKind}",
"Eval_Int".enum("", "1"),
"Eval_Float".enum,
"Eval_ObjCStrLiteral".enum,
"Eval_StrLiteral".enum,
"Eval_CFStr".enum,
"Eval_Other".enum,
"Eval_UnExposed".enum("", "0")
)
EnumConstant(
"{@code enum CXVisitorResult}",
"Visit_Break".enum("", "0"),
"Visit_Continue".enum
)
EnumConstant(
"{@code CXResult}",
"Result_Success".enum("Function returned successfully.", "0"),
"Result_Invalid".enum("One of the parameters was invalid for the function."),
"Result_VisitBreak".enum("The function was terminated by a callback (e.g. it returned CXVisit_Break)")
)
EnumConstant(
"{@code CXIdxEntityKind}",
"IdxEntity_Unexposed".enum("", "0"),
"IdxEntity_Typedef".enum,
"IdxEntity_Function".enum,
"IdxEntity_Variable".enum,
"IdxEntity_Field".enum,
"IdxEntity_EnumConstant".enum,
"IdxEntity_ObjCClass".enum,
"IdxEntity_ObjCProtocol".enum,
"IdxEntity_ObjCCategory".enum,
"IdxEntity_ObjCInstanceMethod".enum,
"IdxEntity_ObjCClassMethod".enum,
"IdxEntity_ObjCProperty".enum,
"IdxEntity_ObjCIvar".enum,
"IdxEntity_Enum".enum,
"IdxEntity_Struct".enum,
"IdxEntity_Union".enum,
"IdxEntity_CXXClass".enum,
"IdxEntity_CXXNamespace".enum,
"IdxEntity_CXXNamespaceAlias".enum,
"IdxEntity_CXXStaticVariable".enum,
"IdxEntity_CXXStaticMethod".enum,
"IdxEntity_CXXInstanceMethod".enum,
"IdxEntity_CXXConstructor".enum,
"IdxEntity_CXXDestructor".enum,
"IdxEntity_CXXConversionFunction".enum,
"IdxEntity_CXXTypeAlias".enum,
"IdxEntity_CXXInterface".enum
)
EnumConstant(
"{@code CXIdxEntityLanguage}",
"IdxEntityLang_None".enum("", "0"),
"IdxEntityLang_C".enum,
"IdxEntityLang_ObjC".enum,
"IdxEntityLang_CXX".enum,
"IdxEntityLang_Swift".enum
)
EnumConstant(
"""
Extra C++ template information for an entity. This can apply to: CXIdxEntity_Function CXIdxEntity_CXXClass CXIdxEntity_CXXStaticMethod
CXIdxEntity_CXXInstanceMethod CXIdxEntity_CXXConstructor CXIdxEntity_CXXConversionFunction CXIdxEntity_CXXTypeAlias
({@code CXIdxEntityCXXTemplateKind})
""",
"IdxEntity_NonTemplate".enum("", "0"),
"IdxEntity_Template".enum,
"IdxEntity_TemplatePartialSpecialization".enum,
"IdxEntity_TemplateSpecialization".enum
)
EnumConstant(
"{@code CXIdxAttrKind}",
"IdxAttr_Unexposed".enum("", "0"),
"IdxAttr_IBAction".enum,
"IdxAttr_IBOutlet".enum,
"IdxAttr_IBOutletCollection".enum
)
EnumConstant(
"{@code CXIdxDeclInfoFlags}",
"IdxDeclFlag_Skipped".enum("", "0x1")
)
EnumConstant(
"{@code CXIdxObjCContainerKind}",
"IdxObjCContainer_ForwardRef".enum("", "0"),
"IdxObjCContainer_Interface".enum,
"IdxObjCContainer_Implementation".enum
)
EnumConstant(
"""
Data for IndexerCallbacks#indexEntityReference. ({@code CXIdxEntityRefKind})
This may be deprecated in a future version as this duplicates the {@code CXSymbolRole_Implicit} bit in {@code CXSymbolRole}.
""",
"IdxEntityRef_Direct".enum("The entity is referenced directly in user's code.", "1"),
"IdxEntityRef_Implicit".enum("An implicit reference, e.g. a reference of an Objective-C method via the dot syntax.")
)
EnumConstant(
"""
Roles that are attributed to symbol occurrences. ({@code CXSymbolRole})
Internal: this currently mirrors low 9 bits of clang::index::SymbolRole with higher bits zeroed. These high bits may be exposed in the future.
""",
"SymbolRole_None".enum("", "0"),
"SymbolRole_Declaration".enum("", "1 << 0"),
"SymbolRole_Definition".enum("", "1 << 1"),
"SymbolRole_Reference".enum("", "1 << 2"),
"SymbolRole_Read".enum("", "1 << 3"),
"SymbolRole_Write".enum("", "1 << 4"),
"SymbolRole_Call".enum("", "1 << 5"),
"SymbolRole_Dynamic".enum("", "1 << 6"),
"SymbolRole_AddressOf".enum("", "1 << 7"),
"SymbolRole_Implicit".enum("", "1 << 8")
)
EnumConstant(
"{@code CXIndexOptFlags}",
"IndexOpt_None".enum("Used to indicate that no special indexing options are needed.", "0x0"),
"IndexOpt_SuppressRedundantRefs".enum(
"""
Used to indicate that IndexerCallbacks#indexEntityReference should be invoked for only one reference of an entity per source file that does not
also include a declaration/definition of the entity.
""",
"0x1"
),
"IndexOpt_IndexFunctionLocalSymbols".enum(
"Function-local symbols should be indexed. If this is not set function-local symbols will be ignored.",
"0x2"
),
"IndexOpt_IndexImplicitTemplateInstantiations".enum(
"Implicit function/class template instantiations should be indexed. If this is not set, implicit instantiations will be ignored.",
"0x4"
),
"IndexOpt_SuppressWarnings".enum("Suppress all compiler warnings when parsing for indexing.", "0x8"),
"IndexOpt_SkipParsedBodiesInSession".enum(
"""
Skip a function/method body that was already parsed during an indexing session associated with a {@code CXIndexAction} object. Bodies in system
headers are always skipped.
""",
"0x10"
)
)
charUTF8.const.p(
"getCString",
"Retrieve the character data associated with the given string.",
CXString("string", "")
)
void(
"disposeString",
"Free the given string.",
CXString("string", "")
)
void(
"disposeStringSet",
"Free the given string set.",
Input..CXStringSet.p("set", "")
)
CXIndex(
"createIndex",
"""
Provides a shared context for creating translation units.
It provides two options:
${ul(
"""
{@code excludeDeclarationsFromPCH}: When non-zero, allows enumeration of "local" declarations (when loading any new translation units). A "local"
declaration is one that belongs in the translation unit itself and not in a precompiled header that was used by the translation unit. If zero, all
declarations will be enumerated.
"""
)}
Here is an example:
${codeBlock("""
// excludeDeclsFromPCH = 1, displayDiagnostics=1
Idx = clang_createIndex(1, 1);
// IndexTest.pch was produced with the following command:
// "clang -x c IndexTest.h -emit-ast -o IndexTest.pch"
TU = clang_createTranslationUnit(Idx, "IndexTest.pch");
// This will load all the symbols from 'IndexTest.pch'
clang_visitChildren(clang_getTranslationUnitCursor(TU),
TranslationUnitVisitor, 0);
clang_disposeTranslationUnit(TU);
// This will load all the symbols from 'IndexTest.c', excluding symbols
// from 'IndexTest.pch'.
char *args[] = { "-Xclang", "-include-pch=IndexTest.pch" };
TU = clang_createTranslationUnitFromSourceFile(Idx, "IndexTest.c", 2, args,
0, 0);
clang_visitChildren(clang_getTranslationUnitCursor(TU),
TranslationUnitVisitor, 0);
clang_disposeTranslationUnit(TU);""")}
This process of creating the {@code pch}, loading it separately, and using it (via {@code -include-pch}) allows {@code excludeDeclsFromPCH} to remove
redundant callbacks (which gives the indexer the same performance benefit as the compiler).
""",
intb("excludeDeclarationsFromPCH", ""),
intb("displayDiagnostics", "")
)
void(
"disposeIndex",
"""
Destroy the given index.
The index must not be destroyed until all of the translation units created within that index have been destroyed.
""",
CXIndex("index", "")
)
void(
"CXIndex_setGlobalOptions",
"""
Sets general options associated with a {@code CXIndex}.
For example:
${codeBlock("""
CXIndex idx = ...;
clang_CXIndex_setGlobalOptions(idx,
clang_CXIndex_getGlobalOptions(idx) |
CXGlobalOpt_ThreadBackgroundPriorityForIndexing);""")}
""",
CXIndex("index", ""),
unsigned("options", "a bitmask of options, a bitwise OR of {@code CXGlobalOpt_XXX} flags")
)
unsigned(
"CXIndex_getGlobalOptions",
"Gets the general options associated with a CXIndex.",
CXIndex("index", ""),
returnDoc = "a bitmask of options, a bitwise OR of {@code CXGlobalOpt_XXX} flags that are associated with the given {@code CXIndex} object"
)
IgnoreMissing..void(
"CXIndex_setInvocationEmissionPathOption",
"""
Sets the invocation emission path option in a {@code CXIndex}.
The invocation emission path specifies a path which will contain log files for certain libclang invocations. A null value (default) implies that
libclang invocations are not logged.
""",
CXIndex("index", ""),
nullable..charUTF8.const.p("Path", "")
)
CXString(
"getFileName",
"Retrieve the complete file and path name of the given file.",
CXFile("SFile", "")
)
time_t(
"getFileTime",
"Retrieve the last modification time of the given file.",
CXFile("SFile", "")
)
int(
"getFileUniqueID",
"Retrieve the unique ID for the given {@code file}.",
CXFile("file", "the file to get the ID for"),
CXFileUniqueID.p("outID", "stores the returned CXFileUniqueID"),
returnDoc = "if there was a failure getting the unique ID, returns non-zero, otherwise returns 0"
)
unsignedb(
"isFileMultipleIncludeGuarded",
"""
Determine whether the given header is guarded against multiple inclusions, either with the conventional \#ifndef/\#define/\#endif macro guards or with
\#pragma once.
""",
CXTranslationUnit("tu", ""),
CXFile("file", "")
)
CXFile(
"getFile",
"Retrieve a file handle within the given translation unit.",
CXTranslationUnit("tu", "the translation unit"),
charUTF8.const.p("file_name", "the name of the file"),
returnDoc =
"the file handle for the named file in the translation unit {@code tu}, or a #NULL file handle if the file was not a part of this translation unit"
)
IgnoreMissing..char.const.p(
"getFileContents",
"Retrieve the buffer associated with the given file.",
CXTranslationUnit("tu", "the translation unit"),
CXFile("file", "the file for which to retrieve the buffer"),
AutoSizeResult..size_t.p("size", "[out] if non-#NULL, will be set to the size of the buffer"),
returnDoc = "a pointer to the buffer in memory that holds the contents of {@code file}, or a #NULL pointer when the file is not loaded"
)
intb(
"File_isEqual",
"Returns non-zero if the {@code file1} and {@code file2} point to the same file, or they are both #NULL.",
nullable..CXFile("file1", ""),
nullable..CXFile("file2", "")
)
IgnoreMissing..CXString(
"File_tryGetRealPathName",
"""
Returns the real path name of {@code file}.
An empty string may be returned. Use #getFileName() in that case.
""",
CXFile("file", "")
)
CXSourceLocation("getNullLocation", "Retrieve a #NULL (invalid) source location.", void())
unsignedb(
"equalLocations",
"Determine whether two source locations, which must refer into the same translation unit, refer to exactly the same point in the source code.",
CXSourceLocation("loc1", ""),
CXSourceLocation("loc2", ""),
returnDoc = "non-zero if the source locations refer to the same location, zero if they refer to different locations"
)
CXSourceLocation(
"getLocation",
"Retrieves the source location associated with a given file/line/column in a particular translation unit.",
CXTranslationUnit("tu", ""),
CXFile("file", ""),
unsigned("line", ""),
unsigned("column", "")
)
CXSourceLocation(
"getLocationForOffset",
"Retrieves the source location associated with a given character offset in a particular translation unit.",
CXTranslationUnit("tu", ""),
CXFile("file", ""),
unsigned("offset", "")
)
intb(
"Location_isInSystemHeader",
"Returns non-zero if the given source location is in a system header.",
CXSourceLocation("location", "")
)
intb(
"Location_isFromMainFile",
"Returns non-zero if the given source location is in the main file of the corresponding translation unit.",
CXSourceLocation("location", "")
)
CXSourceRange("getNullRange", "Retrieve a #NULL (invalid) source range.", void())
CXSourceRange(
"getRange",
"Retrieve a source range given the beginning and ending source locations.",
CXSourceLocation("begin", ""),
CXSourceLocation("end", "")
)
unsignedb(
"equalRanges",
"Determine whether two ranges are equivalent.",
CXSourceRange("range1", ""),
CXSourceRange("range2", ""),
returnDoc = "non-zero if the ranges are the same, zero if they differ"
)
intb(
"Range_isNull",
"Returns non-zero if {@code range} is null.",
CXSourceRange("range", "")
)
void(
"getExpansionLocation",
"""
Retrieve the file, line, column, and offset represented by the given source location.
If the location refers into a macro expansion, retrieves the location of the macro expansion.
""",
CXSourceLocation("location", "the location within a source file that will be decomposed into its parts"),
Check(1)..nullable..CXFile.p("file", "[out] if non-#NULL, will be set to the file to which the given source location points"),
Check(1)..nullable..unsigned.p("line", "[out] if non-#NULL, will be set to the line to which the given source location points"),
Check(1)..nullable..unsigned.p("column", "[out] if non-#NULL, will be set to the column to which the given source location points"),
Check(1)..nullable..unsigned.p("offset", "[out] if non-#NULL, will be set to the offset into the buffer to which the given source location points")
)
void(
"getPresumedLocation",
"""
Retrieve the file, line and column represented by the given source location, as specified in a # line directive.
Example: given the following source code in a file somefile.c
${codeBlock("""
\#123 "dummy.c" 1
static int func(void)
{
return 0;
}""")}
the location information returned by this function would be
File: dummy.c Line: 124 Column: 12
whereas clang_getExpansionLocation would have returned
File: somefile.c Line: 3 Column: 12
""",
CXSourceLocation("location", "the location within a source file that will be decomposed into its parts"),
Check(1)..nullable..CXString.p(
"filename",
"""
[out] if non-#NULL, will be set to the filename of the source location. Note that filenames returned will be for "virtual" files, which don't
necessarily exist on the machine running clang - e.g. when parsing preprocessed output obtained from a different environment. If a non-#NULL value
is passed in, remember to dispose of the returned value using {@code clang_disposeString()} once you've finished with it. For an invalid source
location, an empty string is returned.
"""
),
Check(1)..nullable..unsigned.p(
"line",
"[out] if non-#NULL, will be set to the line number of the source location. For an invalid source location, zero is returned."
),
Check(1)..nullable..unsigned.p(
"column",
"[out] if non-#NULL, will be set to the column number of the source location. For an invalid source location, zero is returned."
)
)
/*void(
"getInstantiationLocation",
"""
Legacy API to retrieve the file, line, column, and offset represented by the given source location.
This interface has been replaced by the newer interface #clang_getExpansionLocation(). See that interface's documentation for details.
""",
CXSourceLocation("location", ""),
CXFile.p("file", ""),
unsigned.p("line", ""),
unsigned.p("column", ""),
unsigned.p("offset", "")
)*/
void(
"getSpellingLocation",
"""
Retrieve the file, line, column, and offset represented by the given source location.
If the location refers into a macro instantiation, return where the location was originally spelled in the source file.
""",
CXSourceLocation("location", "the location within a source file that will be decomposed into its parts"),
Check(1)..nullable..CXFile.p("file", "[out] if non-#NULL, will be set to the file to which the given source location points"),
Check(1)..nullable..unsigned.p("line", "[out] if non-#NULL, will be set to the line to which the given source location points"),
Check(1)..nullable..unsigned.p("column", "[out] if non-#NULL, will be set to the column to which the given source location points"),
Check(1)..nullable..unsigned.p("offset", "[out] if non-#NULL, will be set to the offset into the buffer to which the given source location points")
)
void(
"getFileLocation",
"""
Retrieve the file, line, column, and offset represented by the given source location.
If the location refers into a macro expansion, return where the macro was expanded or where the macro argument was written, if the location points at a
macro argument.
""",
CXSourceLocation("location", "the location within a source file that will be decomposed into its parts"),
Check(1)..nullable..CXFile.p("file", "[out] if non-#NULL, will be set to the file to which the given source location points"),
Check(1)..nullable..unsigned.p("line", "[out] if non-#NULL, will be set to the line to which the given source location points"),
Check(1)..nullable..unsigned.p("column", "[out] if non-#NULL, will be set to the column to which the given source location points"),
Check(1)..nullable..unsigned.p("offset", "[out] if non-#NULL, will be set to the offset into the buffer to which the given source location points")
)
CXSourceLocation(
"getRangeStart",
"Retrieve a source location representing the first character within a source range.",
CXSourceRange("range", "")
)
CXSourceLocation(
"getRangeEnd",
"Retrieve a source location representing the last character within a source range.",
CXSourceRange("range", "")
)
CXSourceRangeList.p(
"getSkippedRanges",
"""
Retrieve all ranges that were skipped by the preprocessor.
The preprocessor will skip lines when they are surrounded by an if/ifdef/ifndef directive whose condition does not evaluate to true.
""",
CXTranslationUnit("tu", ""),
CXFile("file", "")
)
CXSourceRangeList.p(
"getAllSkippedRanges",
"""
Retrieve all ranges from all files that were skipped by the preprocessor.
The preprocessor will skip lines when they are surrounded by an if/ifdef/ifndef directive whose condition does not evaluate to true.
""",
CXTranslationUnit("tu", "")
)
void(
"disposeSourceRangeList",
"Destroy the given {@code CXSourceRangeList}.",
Input..CXSourceRangeList.p("ranges", "")
)
unsigned(
"getNumDiagnosticsInSet",
"Determine the number of diagnostics in a {@code CXDiagnosticSet}.",
CXDiagnosticSet("Diags", "")
)
CXDiagnostic(
"getDiagnosticInSet",
"Retrieve a diagnostic associated with the given {@code CXDiagnosticSet}.",
CXDiagnosticSet("Diags", "the {@code CXDiagnosticSet} to query"),
unsigned("Index", "the zero-based diagnostic number to retrieve"),
returnDoc = "the requested diagnostic. This diagnostic must be freed via a call to #disposeDiagnostic()."
)
CXDiagnosticSet(
"loadDiagnostics",
"Deserialize a set of diagnostics from a Clang diagnostics bitcode file.",
charUTF8.const.p("file", "the name of the file to deserialize"),
Check(1)..CXLoadDiag_Error.p("error", "a pointer to a enum value recording if there was a problem deserializing the diagnostics"),
CXString.p("errorString", "a pointer to a ##CXString for recording the error string if the file was not successfully loaded"),
returnDoc = "a loaded {@code CXDiagnosticSet} if successful, and #NULL otherwise. These diagnostics should be released using #disposeDiagnosticSet()."
)
void(
"disposeDiagnosticSet",
"Release a {@code CXDiagnosticSet} and all of its contained diagnostics.",
CXDiagnosticSet("Diags", "")
)
CXDiagnosticSet(
"getChildDiagnostics",
"""
Retrieve the child diagnostics of a {@code CXDiagnostic}.
This {@code CXDiagnosticSet} does not need to be released by #disposeDiagnosticSet().
""",
CXDiagnostic("D", "")
)
unsigned(
"getNumDiagnostics",
"Determine the number of diagnostics produced for the given translation unit.",
CXTranslationUnit("Unit", "")
)
CXDiagnostic(
"getDiagnostic",
"Retrieve a diagnostic associated with the given translation unit.",
CXTranslationUnit("Unit", "the translation unit to query"),
unsigned("Index", "the zero-based diagnostic number to retrieve"),
returnDoc = "the requested diagnostic. This diagnostic must be freed via a call to #disposeDiagnostic()."
)
CXDiagnosticSet(
"getDiagnosticSetFromTU",
"Retrieve the complete set of diagnostics associated with a translation unit.",
CXTranslationUnit("Unit", "the translation unit to query")
)
void(
"disposeDiagnostic",
"Destroy a diagnostic.",
CXDiagnostic("Diagnostic", "")
)
CXString(
"formatDiagnostic",
"""
Format the given diagnostic in a manner that is suitable for display.
This routine will format the given diagnostic to a string, rendering the diagnostic according to the various options given. The
#defaultDiagnosticDisplayOptions() function returns the set of options that most closely mimics the behavior of the clang compiler.
""",
CXDiagnostic("Diagnostic", "the diagnostic to print"),
unsigned("Options", "a set of options that control the diagnostic display, created by combining {@code CXDiagnosticDisplayOptions} values"),
returnDoc = "a new string containing for formatted diagnostic"
)
unsigned(
"defaultDiagnosticDisplayOptions",
"Retrieve the set of display options most similar to the default behavior of the clang compiler.",
void(),
returnDoc = "a set of display options suitable for use with #formatDiagnostic()"
)
CXDiagnosticSeverity(
"getDiagnosticSeverity",
"Determine the severity of the given diagnostic.",
CXDiagnostic("Diagnostic", "")
)
CXSourceLocation(
"getDiagnosticLocation",
"""
Retrieve the source location of the given diagnostic.
This location is where Clang would print the caret ('^') when displaying the diagnostic on the command line.
""",
CXDiagnostic("Diagnostic", "")
)
CXString(
"getDiagnosticSpelling",
"Retrieve the text of the given diagnostic.",
CXDiagnostic("Diagnostic", "")
)
CXString(
"getDiagnosticOption",
"Retrieve the name of the command-line option that enabled this diagnostic.",
CXDiagnostic("Diag", "the diagnostic to be queried"),
nullable..CXString.p("Disable", "if non-#NULL, will be set to the option that disables this diagnostic (if any)"),
returnDoc = "a string that contains the command-line option used to enable this warning, such as \"-Wconversion\" or \"-pedantic\""
)
unsigned(
"getDiagnosticCategory",
"""
Retrieve the category number for this diagnostic.
Diagnostics can be categorized into groups along with other, related diagnostics (e.g., diagnostics under the same warning flag). This routine
retrieves the category number for the given diagnostic.
""",
CXDiagnostic("Diagnostic", ""),
returnDoc = "the number of the category that contains this diagnostic, or zero if this diagnostic is uncategorized"
)
/*CXString(
"getDiagnosticCategoryName",
"Retrieve the name of a particular diagnostic category. This is now deprecated. Use clang_getDiagnosticCategoryText() instead.",
unsigned("Category", "a diagnostic category number, as returned by {@code clang_getDiagnosticCategory()}"),
returnDoc = "the name of the given diagnostic category"
)*/
CXString(
"getDiagnosticCategoryText",
"Retrieve the diagnostic category text for a given diagnostic.",
CXDiagnostic("Diagnostic", ""),
returnDoc = "the text of the given diagnostic category"
)
unsigned(
"getDiagnosticNumRanges",
"Determine the number of source ranges associated with the given diagnostic.",
CXDiagnostic("Diagnostic", "")
)
CXSourceRange(
"getDiagnosticRange",
"""
Retrieve a source range associated with the diagnostic.
A diagnostic's source ranges highlight important elements in the source code. On the command line, Clang displays source ranges by underlining them
with '~' characters.
""",
CXDiagnostic("Diagnostic", "the diagnostic whose range is being extracted"),
unsigned("Range", "the zero-based index specifying which range to"),
returnDoc = "the requested source range"
)
unsigned(
"getDiagnosticNumFixIts",
"Determine the number of fix-it hints associated with the given diagnostic.",
CXDiagnostic("Diagnostic", "")
)
CXString(
"getDiagnosticFixIt",
"""
Retrieve the replacement information for a given fix-it.
Fix-its are described in terms of a source range whose contents should be replaced by a string. This approach generalizes over three kinds of
operations: removal of source code (the range covers the code to be removed and the replacement string is empty), replacement of source code (the range
covers the code to be replaced and the replacement string provides the new code), and insertion (both the start and end of the range point at the
insertion location, and the replacement string provides the text to insert).
""",
CXDiagnostic("Diagnostic", "the diagnostic whose fix-its are being queried"),
unsigned("FixIt", "the zero-based index of the fix-it"),
CXSourceRange.p(
"ReplacementRange",
"""
the source range whose contents will be replaced with the returned replacement string. Note that source ranges are half-open ranges [a, b), so the
source code should be replaced from a and up to (but not including) b.
"""
),
returnDoc = "a string containing text that should be replace the source code indicated by the {@code ReplacementRange}"
)
CXString(
"getTranslationUnitSpelling",
"Get the original translation unit source file name.",
CXTranslationUnit("CTUnit", "")
)
CXTranslationUnit(
"createTranslationUnitFromSourceFile",
"""
Return the {@code CXTranslationUnit} for a given source file and the provided command line arguments one would pass to the compiler.
Note: The {@code source_filename} argument is optional. If the caller provides a #NULL pointer, the name of the source file is expected to reside in
the specified command line arguments.
Note: When encountered in {@code clang_command_line_args}, the following options are ignored:
${ul(
"'-c'",
"'-emit-ast'",
"'-fsyntax-only'",
"'-o <output file>' (both '-o' and ' <output file>' are ignored)"
)}
""",
CXIndex("CIdx", "the index object with which the translation unit will be associated"),
nullable..charUTF8.const.p(
"source_filename",
"the name of the source file to load, or #NULL if the source file is included in {@code clang_command_line_args}"
),
AutoSize("clang_command_line_args")..int("num_clang_command_line_args", "the number of command-line arguments in {@code clang_command_line_args}"),
nullable..charUTF8.const.p.const.p(
"clang_command_line_args",
"""
the command-line arguments that would be passed to the {@code clang} executable if it were being invoked out-of-process. These command-line options
will be parsed and will affect how the translation unit is parsed. Note that the following options are ignored: '-c', '-emit-ast', '-fsyntax-only'
(which is the default), and '-o <output file>'.
"""
),
AutoSize("unsaved_files")..unsigned("num_unsaved_files", "the number of unsaved file entries in {@code unsaved_files}"),
Input..nullable..CXUnsavedFile.p(
"unsaved_files",
"""
the files that have not yet been saved to disk but may be required for code completion, including the contents of those files. The contents and
name of these files (as specified by {@code CXUnsavedFile}) are copied when necessary, so the client only needs to guarantee their validity until
the call to this function returns.
"""
)
)
CXTranslationUnit(
"createTranslationUnit",
"""
Same as #createTranslationUnit2(), but returns the {@code CXTranslationUnit} instead of an error code. In case of an error this routine returns a
#NULL {@code CXTranslationUnit}, without further detailed error codes.
""",
CXIndex("CIdx", ""),
charUTF8.const.p("ast_filename", "")
)
CXErrorCode(
"createTranslationUnit2",
"Create a translation unit from an AST file ({@code -emit-ast}).",
CXIndex("CIdx", ""),
charUTF8.const.p("ast_filename", ""),
Check(1)..CXTranslationUnit.p("out_TU", "a non-#NULL pointer to store the created {@code CXTranslationUnit}"),
returnDoc = "zero on success, otherwise returns an error code"
)
unsigned(
"defaultEditingTranslationUnitOptions",
"""
Returns the set of flags that is suitable for parsing a translation unit that is being edited.
The set of flags returned provide options for #parseTranslationUnit() to indicate that the translation unit is likely to be reparsed many times, either
explicitly (via #reparseTranslationUnit()) or implicitly (e.g., by code completion (#codeCompleteAt()). The returned flag set contains an unspecified
set of optimizations (e.g., the precompiled preamble) geared toward improving the performance of these routines. The set of optimizations enabled may
change from one version to the next.
""",
void()
)
CXTranslationUnit(
"parseTranslationUnit",
"""
Same as #parseTranslationUnit2(), but returns the {@code CXTranslationUnit} instead of an error code. In case of an error this routine returns a #NULL
{@code CXTranslationUnit}, without further detailed error codes.
""",
CXIndex("CIdx", ""),
nullable..charUTF8.const.p("source_filename", ""),
nullable..charUTF8.const.p.const.p("command_line_args", ""),
AutoSize("command_line_args")..int("num_command_line_args", ""),
Input..nullable..CXUnsavedFile.p("unsaved_files", ""),
AutoSize("unsaved_files")..unsigned("num_unsaved_files", ""),
unsigned("options", "")
)
CXErrorCode(
"parseTranslationUnit2",
"""
Parse the given source file and the translation unit corresponding to that file.
This routine is the main entry point for the Clang C API, providing the ability to parse a source file into a translation unit that can then be queried
by other functions in the API. This routine accepts a set of command-line arguments so that the compilation can be configured in the same way that the
compiler is configured on the command line.
""",
CXIndex("CIdx", "the index object with which the translation unit will be associated"),
nullable..charUTF8.const.p(
"source_filename",
"the name of the source file to load, or #NULL if the source file is included in {@code command_line_args}"),
nullable..charUTF8.const.p.const.p(
"command_line_args",
"""
the command-line arguments that would be passed to the {@code clang} executable if it were being invoked out-of-process. These command-line options
will be parsed and will affect how the translation unit is parsed. Note that the following options are ignored: '-c', '-emit-ast', '-fsyntax-only'
(which is the default), and '-o <output file>'.
"""
),
AutoSize("command_line_args")..int("num_command_line_args", "the number of command-line arguments in {@code command_line_args}"),
Input..nullable..CXUnsavedFile.p(
"unsaved_files",
"""
the files that have not yet been saved to disk but may be required for parsing, including the contents of those files. The contents and name of
these files (as specified by CXUnsavedFile) are copied when necessary, so the client only needs to guarantee their validity until the call to this
function returns.
"""
),
AutoSize("unsaved_files")..unsigned("num_unsaved_files", "the number of unsaved file entries in {@code unsaved_files}"),
unsigned(
"options",
"""
a bitmask of options that affects how the translation unit is managed but not its compilation. This should be a bitwise OR of the
CXTranslationUnit_XXX flags.
"""
),
Check(1)..CXTranslationUnit.p(
"out_TU",
"""
a non-#NULL pointer to store the created {@code CXTranslationUnit}, describing the parsed code and containing any diagnostics produced by the
compiler
"""
),
returnDoc = "zero on success, otherwise returns an error code"
)
CXErrorCode(
"parseTranslationUnit2FullArgv",
"""
Same as #parseTranslationUnit2() but requires a full command line for {@code command_line_args} including {@code argv[0]}. This is useful if the
standard library paths are relative to the binary.
""",
CXIndex("CIdx", ""),
nullable..charUTF8.const.p("source_filename", ""),
charUTF8.const.p.const.p("command_line_args", ""),
AutoSize("command_line_args")..int("num_command_line_args", ""),
nullable..CXUnsavedFile.p("unsaved_files", ""),
AutoSize("unsaved_files")..unsigned("num_unsaved_files", ""),
unsigned("options", ""),
Check(1)..CXTranslationUnit.p("out_TU", "")
)
unsigned(
"defaultSaveOptions",
"""
Returns the set of flags that is suitable for saving a translation unit.
The set of flags returned provide options for #saveTranslationUnit() by default. The returned flag set contains an unspecified set of options that save
translation units with the most commonly-requested data.
""",
CXTranslationUnit("TU", "")
)
int(
"saveTranslationUnit",
"""
Saves a translation unit into a serialized representation of that translation unit on disk.
Any translation unit that was parsed without error can be saved into a file. The translation unit can then be deserialized into a new {@code
CXTranslationUnit} with #createTranslationUnit() or, if it is an incomplete translation unit that corresponds to a header, used as a precompiled header
when parsing other translation units.
""",
CXTranslationUnit("TU", "the translation unit to save"),
charUTF8.const.p("FileName", "the file to which the translation unit will be saved"),
unsigned(
"options",
"a bitmask of options that affects how the translation unit is saved. This should be a bitwise OR of the {@code CXSaveTranslationUnit_XXX} flags."
),
returnDoc =
"""
a value that will match one of the enumerators of the {@code CXSaveError} enumeration. Zero (#SaveError_None) indicates that the translation unit was
saved successfully, while a non-zero value indicates that a problem occurred.
"""
)
unsignedb(
"suspendTranslationUnit",
"""
Suspend a translation unit in order to free memory associated with it.
A suspended translation unit uses significantly less memory but on the other side does not support any other calls than #reparseTranslationUnit() to
resume it or #disposeTranslationUnit() to dispose it completely.
""",
CXTranslationUnit("TU", "")
)
void(
"disposeTranslationUnit",
"Destroy the specified CXTranslationUnit object.",
CXTranslationUnit("TU", "")
)
unsigned(
"defaultReparseOptions",
"""
Returns the set of flags that is suitable for reparsing a translation unit.
The set of flags returned provide options for {@code clang_reparseTranslationUnit()} by default. The returned flag set contains an unspecified set of
optimizations geared toward common uses of reparsing. The set of optimizations enabled may change from one version to the next.
""",
CXTranslationUnit("TU", "")
)
int(
"reparseTranslationUnit",
"""
Reparse the source files that produced this translation unit.
This routine can be used to re-parse the source files that originally created the given translation unit, for example because those source files have
changed (either on disk or as passed via {@code unsaved_files}). The source code will be reparsed with the same command-line options as it was
originally parsed.
Reparsing a translation unit invalidates all cursors and source locations that refer into that translation unit. This makes reparsing a translation
unit semantically equivalent to destroying the translation unit and then creating a new translation unit with the same command-line arguments. However,
it may be more efficient to reparse a translation unit using this routine.
""",
CXTranslationUnit(
"TU",
"""
the translation unit whose contents will be re-parsed. The translation unit must originally have been built with {@code
clang_createTranslationUnitFromSourceFile()}.
"""
),
AutoSize("unsaved_files")..unsigned("num_unsaved_files", "the number of unsaved file entries in {@code unsaved_files}"),
Input..nullable..CXUnsavedFile.p(
"unsaved_files",
"""
the files that have not yet been saved to disk but may be required for parsing, including the contents of those files. The contents and name of
these files (as specified by {@code CXUnsavedFile}) are copied when necessary, so the client only needs to guarantee their validity until the call
to this function returns.
"""
),
unsigned(
"options",
"""
a bitset of options composed of the flags in {@code CXReparse_Flags}. The function #defaultReparseOptions() produces a default set of options
recommended for most uses, based on the translation unit.
"""
),
returnDoc =
"""
0 if the sources could be reparsed. A non-zero error code will be returned if reparsing was impossible, such that the translation unit is invalid. In
such cases, the only valid call for {@code TU} is #disposeTranslationUnit(). The error codes returned by this routine are described by the
{@code CXErrorCode} enum.
"""
)
charUTF8.const.p(
"getTUResourceUsageName",
"Returns the human-readable null-terminated C string that represents the name of the memory category. This string should never be freed.",
CXTUResourceUsageKind("kind", "")
)
CXTUResourceUsage(
"getCXTUResourceUsage",
"Return the memory usage of a translation unit. This object should be released with #disposeCXTUResourceUsage().",
CXTranslationUnit("TU", "")
)
void(
"disposeCXTUResourceUsage",
"",
CXTUResourceUsage("usage", "")
)
CXTargetInfo(
"getTranslationUnitTargetInfo",
"""
Get target information for this translation unit.
The {@code CXTargetInfo} object cannot outlive the {@code CXTranslationUnit} object.
""",
CXTranslationUnit("CTUnit", "")
)
void(
"TargetInfo_dispose",
"Destroy the {@code CXTargetInfo} object.",
CXTargetInfo("Info", "")
)
CXString(
"TargetInfo_getTriple",
"""
Get the normalized target triple as a string.
Returns the empty string in case of any error.
""",
CXTargetInfo("Info", "")
)
int(
"TargetInfo_getPointerWidth",
"""
Get the pointer width of the target in bits.
Returns -1 in case of error.
""",
CXTargetInfo("Info", "")
)
CXCursor("getNullCursor", "Retrieve the #NULL cursor, which represents no entity.", void())
CXCursor(
"getTranslationUnitCursor",
"""
Retrieve the cursor that represents the given translation unit.
The translation unit cursor can be used to start traversing the various declarations within the given translation unit.
""",
CXTranslationUnit("TU", "")
)
unsignedb(
"equalCursors",
"Determine whether two cursors are equivalent.",
CXCursor("A", ""),
CXCursor("B", "")
)
intb(
"Cursor_isNull",
"Returns non-zero if {@code cursor} is null.",
CXCursor("cursor", "")
)
unsigned(
"hashCursor",
"Compute a hash value for the given cursor.",
CXCursor("cursor", "")
)
CXCursorKind(
"getCursorKind",
"Retrieve the kind of the given cursor.",
CXCursor("cursor", "")
)
unsignedb(
"isDeclaration",
"Determine whether the given cursor kind represents a declaration.",
CXCursorKind("kind", "")
)
IgnoreMissing..unsignedb(
"isInvalidDeclaration",
"""
Determine whether the given declaration is invalid.
A declaration is invalid if it could not be parsed successfully.
""",
CXCursor("cursor", ""),
returnDoc = "non-zero if the cursor represents a declaration and it is invalid, otherwise #NULL"
)
unsignedb(
"isReference",
"""
Determine whether the given cursor kind represents a simple reference.
Note that other kinds of cursors (such as expressions) can also refer to other cursors. Use #getCursorReferenced() to determine whether a particular
cursor refers to another entity.
""",
CXCursorKind("kind", "")
)
unsignedb(
"isExpression",
"Determine whether the given cursor kind represents an expression.",
CXCursorKind("kind", "")
)
unsignedb(
"isStatement",
"Determine whether the given cursor kind represents a statement.",
CXCursorKind("kind", "")
)
unsignedb(
"isAttribute",
"Determine whether the given cursor kind represents an attribute.",
CXCursorKind("kind", "")
)
unsignedb(
"Cursor_hasAttrs",
"Determine whether the given cursor has any attributes.",
CXCursor("C", "")
)
unsignedb(
"isInvalid",
"Determine whether the given cursor kind represents an invalid cursor.",
CXCursorKind("kind", "")
)
unsignedb(
"isTranslationUnit",
"Determine whether the given cursor kind represents a translation unit.",
CXCursorKind("kind", "")
)
unsignedb(
"isPreprocessing",
"Determine whether the given cursor represents a preprocessing element, such as a preprocessor directive or macro instantiation.",
CXCursorKind("kind", "")
)
unsignedb(
"isUnexposed",
"Determine whether the given cursor represents a currently unexposed piece of the AST (e.g., CXCursor_UnexposedStmt).",
CXCursorKind("kind", "")
)
CXLinkageKind(
"getCursorLinkage",
"Determine the linkage of the entity referred to by a given cursor.",
CXCursor("cursor", "")
)
CXVisibilityKind(
"getCursorVisibility",
"""
Describe the visibility of the entity referred to by a cursor.
This returns the default visibility if not explicitly specified by a visibility attribute. The default visibility may be changed by commandline
arguments.
""",
CXCursor("cursor", "the cursor to query"),
returnDoc = "the visibility of the cursor"
)
CXAvailabilityKind(
"getCursorAvailability",
"Determine the availability of the entity that this cursor refers to, taking the current target platform into account.",
CXCursor("cursor", "the cursor to query"),
returnDoc = "the availability of the cursor"
)
int(
"getCursorPlatformAvailability",
"""
Determine the availability of the entity that this cursor refers to on any platforms for which availability information is known.
Note that the client is responsible for calling #disposeCXPlatformAvailability() to free each of the platform-availability structures returned. There
are {@code min(N, availability_size)} such structures.
""",
CXCursor("cursor", "the cursor to query"),
Check(1)..nullable..int.p("always_deprecated", "if non-#NULL, will be set to indicate whether the entity is deprecated on all platforms"),
nullable..CXString.p(
"deprecated_message",
"""
if non-#NULL, will be set to the message text provided along with the unconditional deprecation of this entity. The client is responsible for
deallocating this string.
"""
),
Check(1)..nullable..int.p("always_unavailable", "if non-#NULL, will be set to indicate whether the entity is unavailable on all platforms"),
nullable..CXString.p(
"unavailable_message",
"""
if non-#NULL, will be set to the message text provided along with the unconditional unavailability of this entity. The client is responsible for
deallocating this string.
"""
),
Check(1)..nullable..CXPlatformAvailability.p(
"availability",
"""
if non-#NULL, an array of {@code CXPlatformAvailability} instances that will be populated with platform availability information, up to either the
number of platforms for which availability information is available (as returned by this function) or {@code availability_size}, whichever is
smaller
"""
),
AutoSize("availability")..int("availability_size", "the number of elements available in the {@code availability} array"),
returnDoc = "the number of platforms (N) for which availability information is available (which is unrelated to {@code availability_size})"
)
void(
"disposeCXPlatformAvailability",
"Free the memory associated with a {@code CXPlatformAvailability} structure.",
CXPlatformAvailability.p("availability", "")
)
IgnoreMissing..CXCursor(
"Cursor_getVarDeclInitializer",
"If cursor refers to a variable declaration and it has initializer returns cursor referring to the initializer otherwise return null cursor.",
CXCursor("cursor", ""),
since = "12"
)
IgnoreMissing..int(
"Cursor_hasVarDeclGlobalStorage",
"""
If cursor refers to a variable declaration that has global storage returns 1. If cursor refers to a variable declaration that doesn't have global
storage returns 0. Otherwise returns -1.
""",
CXCursor("cursor", ""),
since = "12"
)
IgnoreMissing..int(
"Cursor_hasVarDeclExternalStorage",
"""
If cursor refers to a variable declaration that has external storage returns 1. If cursor refers to a variable declaration that doesn't have external
storage returns 0. Otherwise returns -1.
""",
CXCursor("cursor", ""),
since = "12"
)
CXLanguageKind(
"getCursorLanguage",
"Determine the \"language\" of the entity referred to by a given cursor.",
CXCursor("cursor", "")
)
IgnoreMissing..CXTLSKind(
"getCursorTLSKind",
"Determine the \"thread-local storage (TLS) kind\" of the declaration referred to by a cursor.",
CXCursor("cursor", "")
)
CXTranslationUnit(
"Cursor_getTranslationUnit",
"Returns the translation unit that a cursor originated from.",
CXCursor("cursor", "")
)
CXCursorSet("createCXCursorSet", "Creates an empty CXCursorSet.", void())
void(
"disposeCXCursorSet",
"Disposes a CXCursorSet and releases its associated memory.",
CXCursorSet("cset", "")
)
unsignedb(
"CXCursorSet_contains",
"Queries a CXCursorSet to see if it contains a specific CXCursor.",
CXCursorSet("cset", ""),
CXCursor("cursor", ""),
returnDoc = "non-zero if the set contains the specified cursor"
)
unsignedb(
"CXCursorSet_insert",
"Inserts a CXCursor into a CXCursorSet.",
CXCursorSet("cset", ""),
CXCursor("cursor", ""),
returnDoc = "zero if the CXCursor was already in the set, and non-zero otherwise"
)
CXCursor(
"getCursorSemanticParent",
"""
Determine the semantic parent of the given cursor.
The semantic parent of a cursor is the cursor that semantically contains the given {@code cursor}. For many declarations, the lexical and semantic
parents are equivalent (the lexical parent is returned by #getCursorLexicalParent()). They diverge when declarations or definitions are provided
out-of-line. For example:
${codeBlock("""
class C {
void f();
};
void C::f() { }""")}
In the out-of-line definition of {@code C::f}, the semantic parent is the class {@code C}, of which this function is a member. The lexical parent is
the place where the declaration actually occurs in the source code; in this case, the definition occurs in the translation unit. In general, the
lexical parent for a given entity can change without affecting the semantics of the program, and the lexical parent of different declarations of the
same entity may be different. Changing the semantic parent of a declaration, on the other hand, can have a major impact on semantics, and
redeclarations of a particular entity should all have the same semantic context.
In the example above, both declarations of {@code C::f} have {@code C} as their semantic context, while the lexical context of the first {@code C::f}
is {@code C} and the lexical context of the second {@code C::f} is the translation unit.
For global declarations, the semantic parent is the translation unit.
""",
CXCursor("cursor", "")
)
CXCursor(
"getCursorLexicalParent",
"""
Determine the lexical parent of the given cursor.
The lexical parent of a cursor is the cursor in which the given {@code cursor} was actually written. For many declarations, the lexical and semantic
parents are equivalent (the semantic parent is returned by #getCursorSemanticParent()). They diverge when declarations or definitions are provided
out-of-line. For example:
${codeBlock("""
class C {
void f();
};
void C::f() { }""")}
In the out-of-line definition of {@code C::f}, the semantic parent is the class {@code C}, of which this function is a member. The lexical parent is
the place where the declaration actually occurs in the source code; in this case, the definition occurs in the translation unit. In general, the
lexical parent for a given entity can change without affecting the semantics of the program, and the lexical parent of different declarations of the
same entity may be different. Changing the semantic parent of a declaration, on the other hand, can have a major impact on semantics, and
redeclarations of a particular entity should all have the same semantic context.
In the example above, both declarations of {@code C::f} have {@code C} as their semantic context, while the lexical context of the first {@code C::f}
is {@code C} and the lexical context of the second {@code C::f} is the translation unit.
For declarations written in the global scope, the lexical parent is the translation unit.
""",
CXCursor("cursor", "")
)
void(
"getOverriddenCursors",
"""
Determine the set of methods that are overridden by the given method.
In both Objective-C and C++, a method (aka virtual member function, in C++) can override a virtual method in a base class. For Objective-C, a method is
said to override any method in the class's base class, its protocols, or its categories' protocols, that has the same selector and is of the same kind
(class or instance). If no such method exists, the search continues to the class's superclass, its protocols, and its categories, and so on. A method
from an Objective-C implementation is considered to override the same methods as its corresponding method in the interface.
For C++, a virtual member function overrides any virtual member function with the same signature that occurs in its base classes. With multiple
inheritance, a virtual member function can override several virtual member functions coming from different base classes.
In all cases, this function determines the immediate overridden method, rather than all of the overridden methods. For example, if a method is
originally declared in a class A, then overridden in B (which in inherits from A) and also in C (which inherited from B), then the only overridden
method returned from this function when invoked on C's method will be B's method. The client may then invoke this function again, given the
previously-found overridden methods, to map out the complete method-override set.
""",
CXCursor("cursor", "a cursor representing an Objective-C or C++ method. This routine will compute the set of methods that this method overrides."),
Check(1)..CXCursor.p.p(
"overridden",
"""
a pointer whose pointee will be replaced with a pointer to an array of cursors, representing the set of overridden methods. If there are no
overridden methods, the pointee will be set to #NULL. The pointee must be freed via a call to #disposeOverriddenCursors().
"""
),
Check(1)..unsigned.p(
"num_overridden",
"a pointer to the number of overridden functions, will be set to the number of overridden functions in the array pointed to by {@code overridden}"
)
)
void(
"disposeOverriddenCursors",
"Free the set of overridden cursors returned by {@code clang_getOverriddenCursors()}.",
Unsafe..CXCursor.p("overridden", "")
)
CXFile(
"getIncludedFile",
"Retrieve the file that is included by the given inclusion directive cursor.",
CXCursor("cursor", "")
)
CXCursor(
"getCursor",
"""
Map a source location to the cursor that describes the entity at that location in the source code.
{@code clang_getCursor()} maps an arbitrary source location within a translation unit down to the most specific cursor that describes the entity at that
location. For example, given an expression {@code x + y}, invoking {@code clang_getCursor()} with a source location pointing to "x" will return the
cursor for "x"; similarly for "y". If the cursor points anywhere between "x" or "y" (e.g., on the + or the whitespace around it), clang_getCursor()
will return a cursor referring to the "+" expression.
""",
CXTranslationUnit("TU", ""),
CXSourceLocation("location", ""),
returnDoc = "a cursor representing the entity at the given source location, or a #NULL cursor if no such entity can be found"
)
CXSourceLocation(
"getCursorLocation",
"""
Retrieve the physical location of the source constructor referenced by the given cursor.
The location of a declaration is typically the location of the name of that declaration, where the name of that declaration would occur if it is
unnamed, or some keyword that introduces that particular declaration. The location of a reference is where that reference occurs within the source
code.
""",
CXCursor("cursor", "")
)
CXSourceRange(
"getCursorExtent",
"""
Retrieve the physical extent of the source construct referenced by the given cursor.
The extent of a cursor starts with the file/line/column pointing at the first character within the source construct that the cursor refers to and ends
with the last character within that source construct. For a declaration, the extent covers the declaration itself. For a reference, the extent covers
the location of the reference (e.g., where the referenced entity was actually used).
""",
CXCursor("cursor", "")
)
CXType(
"getCursorType",
"Retrieve the type of a {@code CXCursor} (if any).",
CXCursor("C", "")
)
CXString(
"getTypeSpelling",
"""
Pretty-print the underlying type using the rules of the language of the translation unit from which it came.
If the type is invalid, an empty string is returned.
""",
CXType("CT", "")
)
CXType(
"getTypedefDeclUnderlyingType",
"""
Retrieve the underlying type of a typedef declaration.
If the cursor does not reference a typedef declaration, an invalid type is returned.
""",
CXCursor("C", "")
)
CXType(
"getEnumDeclIntegerType",
"""
Retrieve the integer type of an enum declaration.
If the cursor does not reference an enum declaration, an invalid type is returned.
""",
CXCursor("C", "")
)
long_long(
"getEnumConstantDeclValue",
"""
Retrieve the integer value of an enum constant declaration as a signed long long.
If the cursor does not reference an enum constant declaration, {@code LLONG_MIN} is returned. Since this is also potentially a valid constant value,
the kind of the cursor must be verified before calling this function.
""",
CXCursor("C", "")
)
unsigned_long_long(
"getEnumConstantDeclUnsignedValue",
"""
Retrieve the integer value of an enum constant declaration as an unsigned long long.
If the cursor does not reference an enum constant declaration, {@code ULLONG_MAX} is returned. Since this is also potentially a valid constant value,
the kind of the cursor must be verified before calling this function.
""",
CXCursor("C", "")
)
int(
"getFieldDeclBitWidth",
"""
Retrieve the bit width of a bit field declaration as an integer.
If a cursor that is not a bit field declaration is passed in, -1 is returned.
""",
CXCursor("C", "")
)
int(
"Cursor_getNumArguments",
"""
Retrieve the number of non-variadic arguments associated with a given cursor.
The number of arguments can be determined for calls as well as for declarations of functions or methods. For other cursors -1 is returned.
""",
CXCursor("C", "")
)
CXCursor(
"Cursor_getArgument",
"""
Retrieve the argument cursor of a function or method.
The argument cursor can be determined for calls as well as for declarations of functions or methods. For other cursors and for invalid indices, an
invalid cursor is returned.
""",
CXCursor("C", ""),
unsigned("i", "")
)
int(
"Cursor_getNumTemplateArguments",
"""
Returns the number of template args of a function decl representing a template specialization.
If the argument cursor cannot be converted into a template function declaration, -1 is returned.
For example, for the following declaration and specialization:
${codeBlock("""
template <typename T, int kInt, bool kBool>
void foo() { ... }
template <>
void foo <float , -7, true>();""")}
The value 3 would be returned from this call.
""",
CXCursor("C", "")
)
CXTemplateArgumentKind(
"Cursor_getTemplateArgumentKind",
"""
Retrieve the kind of the I'th template argument of the {@code CXCursor} {@code C}.
If the argument {@code CXCursor} does not represent a {@code FunctionDecl}, an invalid template argument kind is returned.
For example, for the following declaration and specialization:
${codeBlock("""
template <typename T, int kInt, bool kBool>
void foo() { ... }
template <>
void foo <float , -7, true>();""")}
For I = 0, 1, and 2, {@code Type}, {@code Integral}, and {@code Integral} will be returned, respectively.
""",
CXCursor("C", ""),
unsigned("I", "")
)
CXType(
"Cursor_getTemplateArgumentType",
"""
Retrieve a {@code CXType} representing the type of a {@code TemplateArgument} of a function decl representing a template specialization.
If the argument {@code CXCursor does} not represent a {@code FunctionDecl} whose {@code I}'th template argument has a kind of
{@code CXTemplateArgKind_Integral}, an invalid type is returned.
For example, for the following declaration and specialization:
${codeBlock("""
template <typename T, int kInt, bool kBool>
void foo() { ... }
template <>
void foo <float , -7, true>();""")}
If called with I = 0, "float", will be returned. Invalid types will be returned for I == 1 or 2.
""",
CXCursor("C", ""),
unsigned("I", "")
)
long_long(
"Cursor_getTemplateArgumentValue",
"""
Retrieve the value of an {@code Integral} {@code TemplateArgument} (of a function decl representing a template specialization) as a {@code signed long
long}.
It is undefined to call this function on a {@code CXCursor} that does not represent a {@code FunctionDecl} or whose {@code I}'th template argument is
not an integral value.
For example, for the following declaration and specialization:
${codeBlock("""
template <typename T, int kInt, bool kBool>
void foo() { ... }
template <>
void foo <float , -7, true>();""")}
If called with I = 1 or 2, -7 or true will be returned, respectively. For I == 0, this function's behavior is undefined.
""",
CXCursor("C", ""),
unsigned("I", "")
)
unsigned_long_long(
"Cursor_getTemplateArgumentUnsignedValue",
"""
Retrieve the value of an {@code Integral} {@code TemplateArgument} (of a function decl representing a template specialization) as an {@code unsigned
long long}.
It is undefined to call this function on a {@code CXCursor} that does not represent a {@code FunctionDecl} or whose {@code I}'th template argument is
not an integral value.
For example, for the following declaration and specialization:
${codeBlock("""
template <typename T, int kInt, bool kBool>
void foo() { ... }
template <>
void foo <float , 2147483649, true>();""")}
If called with I = 1 or 2, 2147483649 or true will be returned, respectively. For I == 0, this function's behavior is undefined.
""",
CXCursor("C", ""),
unsigned("I", "")
)
unsignedb(
"equalTypes",
"Determine whether two {@code CXTypes} represent the same type.",
CXType("A", ""),
CXType("B", ""),
returnDoc = "non-zero if the {@code CXTypes} represent the same type and zero otherwise"
)
CXType(
"getCanonicalType",
"""
Return the canonical type for a {@code CXType}.
Clang's type system explicitly models typedefs and all the ways a specific type can be represented. The canonical type is the underlying type with all
the "sugar" removed. For example, if 'T' is a typedef for 'int', the canonical type for 'T' would be 'int'.
""",
CXType("T", "")
)
unsignedb(
"isConstQualifiedType",
"""
Determine whether a {@code CXType} has the "const" qualifier set, without looking through typedefs that may have added "const" at a different level.
""",
CXType("T", "")
)
unsignedb(
"Cursor_isMacroFunctionLike",
"Determine whether a {@code CXCursor} that is a macro, is function like.",
CXCursor("C", "")
)
unsignedb(
"Cursor_isMacroBuiltin",
"Determine whether a {@code CXCursor} that is a macro, is a builtin one.",
CXCursor("C", "")
)
unsignedb(
"Cursor_isFunctionInlined",
"Determine whether a {@code CXCursor} that is a function declaration, is an inline declaration.",
CXCursor("C", "")
)
unsignedb(
"isVolatileQualifiedType",
"""
Determine whether a {@code CXType} has the "volatile" qualifier set, without looking through typedefs that may have added "volatile" at a different
level.
""",
CXType("T", "")
)
unsignedb(
"isRestrictQualifiedType",
"""
Determine whether a {@code CXType} has the "restrict" qualifier set, without looking through typedefs that may have added "restrict" at a different
level.
""",
CXType("T", "")
)
unsigned(
"getAddressSpace",
"Returns the address space of the given type.",
CXType("T", "")
)
CXString(
"getTypedefName",
"Returns the typedef name of the given type.",
CXType("CT", "")
)
CXType(
"getPointeeType",
"For pointer types, returns the type of the pointee.",
CXType("T", "")
)
CXCursor(
"getTypeDeclaration",
"Return the cursor for the declaration of the given type.",
CXType("T", "")
)
CXString(
"getDeclObjCTypeEncoding",
"Returns the Objective-C type encoding for the specified declaration.",
CXCursor("C", "")
)
CXString(
"Type_getObjCEncoding",
"Returns the Objective-C type encoding for the specified {@code CXType}.",
CXType("type", "")
)
CXString(
"getTypeKindSpelling",
"Retrieve the spelling of a given {@code CXTypeKind}.",
CXTypeKind("K", "")
)
CXCallingConv(
"getFunctionTypeCallingConv",
"""
Retrieve the calling convention associated with a function type.
If a non-function type is passed in, #CallingConv_Invalid is returned.
""",
CXType("T", "")
)
CXType(
"getResultType",
"""
Retrieve the return type associated with a function type.
If a non-function type is passed in, an invalid type is returned.
""",
CXType("T", "")
)
int(
"getExceptionSpecificationType",
"""
Retrieve the exception specification type associated with a function type. This is a value of type {@code CXCursor_ExceptionSpecificationKind}.
If a non-function type is passed in, an error code of -1 is returned.
""",
CXType("T", "")
)
int(
"getNumArgTypes",
"""
Retrieve the number of non-variadic parameters associated with a function type.
If a non-function type is passed in, -1 is returned.
""",
CXType("T", "")
)
CXType(
"getArgType",
"""
Retrieve the type of a parameter of a function type.
If a non-function type is passed in or the function does not have enough parameters, an invalid type is returned.
""",
CXType("T", ""),
unsigned("i", "")
)
IgnoreMissing..CXType(
"Type_getObjCObjectBaseType",
"""
Retrieves the base type of the {@code ObjCObjectType}.
If the type is not an ObjC object, an invalid type is returned.
""",
CXType("T", "")
)
IgnoreMissing..unsigned(
"Type_getNumObjCProtocolRefs",
"""
Retrieve the number of protocol references associated with an ObjC object/id.
If the type is not an ObjC object, 0 is returned.
""",
CXType("T", "")
)
IgnoreMissing..CXCursor(
"Type_getObjCProtocolDecl",
"""
Retrieve the decl for a protocol reference for an ObjC object/id.
If the type is not an ObjC object or there are not enough protocol references, an invalid cursor is returned.
""",
CXType("T", ""),
unsigned("i", "")
)
IgnoreMissing..unsigned(
"Type_getNumObjCTypeArgs",
"""
Retrieve the number of type arguments associated with an ObjC object.
If the type is not an ObjC object, 0 is returned.
""",
CXType("T", "")
)
IgnoreMissing..CXType(
"Type_getObjCTypeArg",
"""
Retrieve a type argument associated with an ObjC object.
If the type is not an ObjC or the index is not valid, an invalid type is returned.
""",
CXType("T", ""),
unsigned("i", "")
)
unsignedb(
"isFunctionTypeVariadic",
"Return 1 if the {@code CXType} is a variadic function type, and 0 otherwise.",
CXType("T", "")
)
CXType(
"getCursorResultType",
"""
Retrieve the return type associated with a given cursor.
This only returns a valid type if the cursor refers to a function or method.
""",
CXCursor("C", "")
)
int(
"getCursorExceptionSpecificationType",
"""
Retrieve the exception specification type associated with a given cursor. This is a value of type {@code CXCursor_ExceptionSpecificationKind}.
This only returns a valid result if the cursor refers to a function or method.
""",
CXCursor("C", "")
)
unsignedb(
"isPODType",
"Return 1 if the {@code CXType} is a POD (plain old data) type, and 0 otherwise.",
CXType("T", "")
)
CXType(
"getElementType",
"""
Return the element type of an array, complex, or vector type.
If a type is passed in that is not an array, complex, or vector type, an invalid type is returned.
""",
CXType("T", "")
)
long_long(
"getNumElements",
"""
Return the number of elements of an array or vector type.
If a type is passed in that is not an array or vector type, -1 is returned.
""",
CXType("T", "")
)
CXType(
"getArrayElementType",
"""
Return the element type of an array type.
If a non-array type is passed in, an invalid type is returned.
""",
CXType("T", "")
)
long_long(
"getArraySize",
"""
Return the array size of a constant array.
If a non-array type is passed in, -1 is returned.
""",
CXType("T", "")
)
CXType(
"Type_getNamedType",
"""
Retrieve the type named by the qualified-id.
If a non-elaborated type is passed in, an invalid type is returned.
""",
CXType("T", "")
)
unsignedb(
"Type_isTransparentTagTypedef",
"""
Determine if a typedef is 'transparent' tag.
A typedef is considered 'transparent' if it shares a name and spelling location with its underlying tag type, as is the case with the {@code NS_ENUM}
macro.
""",
CXType("T", ""),
returnDoc = "non-zero if transparent and zero otherwise"
)
IgnoreMissing..CXTypeNullabilityKind(
"Type_getNullability",
"Retrieve the nullability kind of a pointer type.",
CXType("T", "")
)
long_long(
"Type_getAlignOf",
"""
Return the alignment of a type in bytes as per {@code C++[expr.alignof]} standard.
If the type declaration is invalid, #TypeLayoutError_Invalid is returned. If the type declaration is an incomplete type, #TypeLayoutError_Incomplete is
returned. If the type declaration is a dependent type, #TypeLayoutError_Dependent is returned. If the type declaration is not a constant size type,
#TypeLayoutError_NotConstantSize is returned.
""",
CXType("T", "")
)
CXType(
"Type_getClassType",
"""
Return the class type of an member pointer type.
If a non-member-pointer type is passed in, an invalid type is returned.
""",
CXType("T", "")
)
long_long(
"Type_getSizeOf",
"""
Return the size of a type in bytes as per {@code C++[expr.sizeof]} standard.
If the type declaration is invalid, #TypeLayoutError_Invalid is returned. If the type declaration is an incomplete type, #TypeLayoutError_Incomplete is
returned. If the type declaration is a dependent type, #TypeLayoutError_Dependent is returned.
""",
CXType("T", "")
)
long_long(
"Type_getOffsetOf",
"""
Return the offset of a field named {@code S} in a record of type {@code T} in bits as it would be returned by {@code __offsetof__} as per
{@code C++11[18.2p4]}
If the cursor is not a record field declaration, #TypeLayoutError_Invalid is returned. If the field's type declaration is an incomplete type,
#TypeLayoutError_Incomplete is returned. If the field's type declaration is a dependent type, #TypeLayoutError_Dependent is returned. If the field's
name {@code S} is not found, #TypeLayoutError_InvalidFieldName is returned.
""",
CXType("T", ""),
charUTF8.const.p("S", "")
)
IgnoreMissing..CXType(
"Type_getModifiedType",
"""
Return the type that was modified by this attributed type.
If the type is not an attributed type, an invalid type is returned.
""",
CXType("T", "")
)
IgnoreMissing..CXType(
"Type_getValueType",
"""
Gets the type contained by this atomic type.
If a non-atomic type is passed in, an invalid type is returned.
""",
CXType("CT", ""),
since = "11"
)
long_long(
"Cursor_getOffsetOfField",
"""
Return the offset of the field represented by the Cursor.
If the cursor is not a field declaration, -1 is returned. If the cursor semantic parent is not a record field declaration, #TypeLayoutError_Invalid is
returned. If the field's type declaration is an incomplete type, #TypeLayoutError_Incomplete is returned. If the field's type declaration is a
dependent type, #TypeLayoutError_Dependent is returned. If the field's name S is not found, #TypeLayoutError_InvalidFieldName is returned.
""",
CXCursor("C", "")
)
unsignedb(
"Cursor_isAnonymous",
"Determine whether the given cursor represents an anonymous tag or namespace.",
CXCursor("C", "")
)
IgnoreMissing..unsignedb(
"Cursor_isAnonymousRecordDecl",
"Determine whether the given cursor represents an anonymous record declaration.",
CXCursor("C", ""),
since = "9"
)
IgnoreMissing..unsignedb(
"Cursor_isInlineNamespace",
"Determine whether the given cursor represents an inline namespace declaration.",
CXCursor("C", ""),
since = "9"
)
int(
"Type_getNumTemplateArguments",
"Returns the number of template arguments for given template specialization, or -1 if type {@code T} is not a template specialization.",
CXType("T", "")
)
CXType(
"Type_getTemplateArgumentAsType",
"""
Returns the type template argument of a template class specialization at given index.
This function only returns template type arguments and does not handle template template arguments or variadic packs.
""",
CXType("T", ""),
unsigned("i", "")
)
CXRefQualifierKind(
"Type_getCXXRefQualifier",
"""
Retrieve the ref-qualifier kind of a function or method.
The ref-qualifier is returned for C++ functions or methods. For other types or non-C++ declarations, #RefQualifier_None is returned.
""",
CXType("T", "")
)
unsignedb(
"Cursor_isBitField",
"Returns non-zero if the cursor specifies a Record member that is a bitfield.",
CXCursor("C", "")
)
unsignedb(
"isVirtualBase",
"Returns 1 if the base class specified by the cursor with kind #Cursor_CXXBaseSpecifier is virtual.",
CXCursor("cursor", "")
)
CX_CXXAccessSpecifier(
"getCXXAccessSpecifier",
"""
Returns the access control level for the referenced object.
If the cursor refers to a C++ declaration, its access control level within its parent scope is returned. Otherwise, if the cursor refers to a base
specifier or access specifier, the specifier itself is returned.
""",
CXCursor("cursor", "")
)
CX_StorageClass(
"Cursor_getStorageClass",
"""
Returns the storage class for a function or variable declaration.
If the passed in Cursor is not a function or variable declaration, #_SC_Invalid is returned else the storage class.
""",
CXCursor("cursor", "")
)
unsigned(
"getNumOverloadedDecls",
"Determine the number of overloaded declarations referenced by a #Cursor_OverloadedDeclRef cursor.",
CXCursor("cursor", "the cursor whose overloaded declarations are being queried"),
returnDoc = "the number of overloaded declarations referenced by {@code cursor}. If it is not a {@code CXCursor_OverloadedDeclRef} cursor, returns 0."
)
CXCursor(
"getOverloadedDecl",
"Retrieve a cursor for one of the overloaded declarations referenced by a #Cursor_OverloadedDeclRef cursor.",
CXCursor("cursor", "the cursor whose overloaded declarations are being queried"),
unsigned("index", "the zero-based index into the set of overloaded declarations in the cursor"),
returnDoc =
"""
a cursor representing the declaration referenced by the given {@code cursor} at the specified {@code index}. If the cursor does not have an associated
set of overloaded declarations, or if the index is out of bounds, returns #getNullCursor();
"""
)
CXType(
"getIBOutletCollectionType",
"For cursors representing an {@code iboutletcollection} attribute, this function returns the collection element type.",
CXCursor("cursor", "")
)
unsignedb(
"visitChildren",
"""
Visit the children of a particular cursor.
This function visits all the direct children of the given cursor, invoking the given {@code visitor} function with the cursors of each visited child.
The traversal may be recursive, if the visitor returns #ChildVisit_Recurse. The traversal may also be ended prematurely, if the visitor returns
#ChildVisit_Break.
""",
CXCursor(
"parent",
"the cursor whose child may be visited. All kinds of cursors can be visited, including invalid cursors (which, by definition, have no children)."
),
CXCursorVisitor("visitor", "the visitor function that will be invoked for each child of {@code parent}"),
nullable..CXClientData(
"client_data",
"pointer data supplied by the client, which will be passed to the visitor each time it is invoked"
),
returnDoc = "a non-zero value if the traversal was terminated prematurely by the visitor returning #ChildVisit_Break"
)
CXString(
"getCursorUSR",
"""
Retrieve a Unified Symbol Resolution (USR) for the entity referenced by the given cursor.
A Unified Symbol Resolution (USR) is a string that identifies a particular entity (function, class, variable, etc.) within a program. USRs can be
compared across translation units to determine, e.g., when references in one translation refer to an entity defined in another translation unit.
""",
CXCursor("cursor", "")
)
CXString(
"constructUSR_ObjCClass",
"Construct a USR for a specified Objective-C class.",
charUTF8.const.p("class_name", "")
)
CXString(
"constructUSR_ObjCCategory",
"Construct a USR for a specified Objective-C category.",
charUTF8.const.p("class_name", ""),
charUTF8.const.p("category_name", "")
)
CXString(
"constructUSR_ObjCProtocol",
"Construct a USR for a specified Objective-C protocol.",
charUTF8.const.p("protocol_name", "")
)
CXString(
"constructUSR_ObjCIvar",
"Construct a USR for a specified Objective-C instance variable and the USR for its containing class.",
charUTF8.const.p("name", ""),
CXString("classUSR", "")
)
CXString(
"constructUSR_ObjCMethod",
"Construct a USR for a specified Objective-C method and the USR for its containing class.",
charUTF8.const.p("name", ""),
unsignedb("isInstanceMethod", ""),
CXString("classUSR", "")
)
CXString(
"constructUSR_ObjCProperty",
"Construct a USR for a specified Objective-C property and the USR for its containing class.",
charUTF8.const.p("property", ""),
CXString("classUSR", "")
)
CXString(
"getCursorSpelling",
"Retrieve a name for the entity referenced by this cursor.",
CXCursor("cursor", "")
)
CXSourceRange(
"Cursor_getSpellingNameRange",
"""
Retrieve a range for a piece that forms the cursors spelling name. Most of the times there is only one range for the complete spelling but for
Objective-C methods and Objective-C message expressions, there are multiple pieces for each selector identifier.
""",
CXCursor("cursor", ""),
unsigned(
"pieceIndex",
"the index of the spelling name piece. If this is greater than the actual number of pieces, it will return a #NULL (invalid) range."
),
unsigned("options", "reserved")
)
IgnoreMissing..unsigned(
"PrintingPolicy_getProperty",
"Get a property value for the given printing policy.",
CXPrintingPolicy("Policy", ""),
CXPrintingPolicyProperty("Property", "")
)
IgnoreMissing..void(
"PrintingPolicy_setProperty",
"Set a property value for the given printing policy.",
CXPrintingPolicy("Policy", ""),
CXPrintingPolicyProperty("Property", ""),
unsigned("Value", "")
)
IgnoreMissing..CXPrintingPolicy(
"getCursorPrintingPolicy",
"""
Retrieve the default policy for the cursor.
The policy should be released after use with {@code clang_PrintingPolicy_dispose}.
""",
CXCursor("cursor", "")
)
IgnoreMissing..void(
"PrintingPolicy_dispose",
"Release a printing policy.",
CXPrintingPolicy("Policy", "")
)
IgnoreMissing..CXString(
"getCursorPrettyPrinted",
"Pretty print declarations.",
CXCursor("Cursor", "the cursor representing a declaration"),
CXPrintingPolicy("Policy", "the policy to control the entities being printed. If #NULL, a default policy is used."),
returnDoc = "the pretty printed declaration or the empty string for other cursors"
)
CXString(
"getCursorDisplayName",
"""
Retrieve the display name for the entity referenced by this cursor.
The display name contains extra information that helps identify the cursor, such as the parameters of a function or template or the arguments of a
class template specialization.
""",
CXCursor("cursor", "")
)
CXCursor(
"getCursorReferenced",
"""
For a cursor that is a reference, retrieve a cursor representing the entity that it references.
Reference cursors refer to other entities in the AST. For example, an Objective-C superclass reference cursor refers to an Objective-C class. This
function produces the cursor for the Objective-C class from the cursor for the superclass reference. If the input cursor is a declaration or
definition, it returns that declaration or definition unchanged. Otherwise, returns the #NULL cursor.
""",
CXCursor("cursor", "")
)
CXCursor(
"getCursorDefinition",
"""
For a cursor that is either a reference to or a declaration of some entity, retrieve a cursor that describes the definition of that entity.
Some entities can be declared multiple times within a translation unit, but only one of those declarations can also be a definition. For example,
given:
${codeBlock("""
int f(int, int);
int g(int x, int y) { return f(x, y); }
int f(int a, int b) { return a + b; }
int f(int, int);""")}
there are three declarations of the function "f", but only the second one is a definition. The {@code clang_getCursorDefinition()} function will take
any cursor pointing to a declaration of "f" (the first or fourth lines of the example) or a cursor referenced that uses "f" (the call to "f' inside
"g") and will return a declaration cursor pointing to the definition (the second "f" declaration).
If given a cursor for which there is no corresponding definition, e.g., because there is no definition of that entity within this translation unit,
returns a #NULL cursor.
""",
CXCursor("cursor", "")
)
unsignedb(
"isCursorDefinition",
"Determine whether the declaration pointed to by this cursor is also a definition of that entity.",
CXCursor("cursor", "")
)
CXCursor(
"getCanonicalCursor",
"""
Retrieve the canonical cursor corresponding to the given cursor.
In the C family of languages, many kinds of entities can be declared several times within a single translation unit. For example, a structure type can
be forward-declared (possibly multiple times) and later defined:
${codeBlock("""
struct X;
struct X;
struct X {
int member;
};""")}
The declarations and the definition of {@code X} are represented by three different cursors, all of which are declarations of the same underlying
entity. One of these cursor is considered the "canonical" cursor, which is effectively the representative for the underlying entity. One can determine
if two cursors are declarations of the same underlying entity by comparing their canonical cursors.
""",
CXCursor("cursor", ""),
returnDoc = "the canonical cursor for the entity referred to by the given cursor"
)
int(
"Cursor_getObjCSelectorIndex",
"""
If the cursor points to a selector identifier in an Objective-C method or message expression, this returns the selector index.
After getting a cursor with #getCursor(), this can be called to determine if the location points to a selector identifier.
""",
CXCursor("cursor", ""),
returnDoc =
"the selector index if the cursor is an Objective-C method or message expression and the cursor is pointing to a selector identifier, or -1 otherwise"
)
intb(
"Cursor_isDynamicCall",
"""
Given a cursor pointing to a C++ method call or an Objective-C message, returns non-zero if the method/message is "dynamic", meaning:
For a C++ method: the call is virtual. For an Objective-C message: the receiver is an object instance, not 'super' or a specific class.
If the method/message is "static" or the cursor does not point to a method/message, it will return zero.
""",
CXCursor("C", "")
)
CXType(
"Cursor_getReceiverType",
"Given a cursor pointing to an Objective-C message or property reference, or C++ method call, returns the {@code CXType} of the receiver.",
CXCursor("C", "")
)
unsigned(
"Cursor_getObjCPropertyAttributes",
"""
Given a cursor that represents a property declaration, return the associated property attributes. The bits are formed from {@code
CXObjCPropertyAttrKind}.
""",
CXCursor("C", ""),
unsigned("reserved", "reserved for future use, pass 0")
)
IgnoreMissing..CXString(
"Cursor_getObjCPropertyGetterName",
"Given a cursor that represents a property declaration, return the name of the method that implements the getter.",
CXCursor("C", "")
)
IgnoreMissing..CXString(
"Cursor_getObjCPropertySetterName",
"Given a cursor that represents a property declaration, return the name of the method that implements the setter, if any.",
CXCursor("C", "")
)
unsigned(
"Cursor_getObjCDeclQualifiers",
"""
Given a cursor that represents an Objective-C method or parameter declaration, return the associated Objective-C qualifiers for the return type or the
parameter respectively. The bits are formed from CXObjCDeclQualifierKind.
""",
CXCursor("C", "")
)
unsignedb(
"Cursor_isObjCOptional",
"""
Given a cursor that represents an Objective-C method or property declaration, return non-zero if the declaration was affected by "@optional". Returns
zero if the cursor is not such a declaration or it is "@required".
""",
CXCursor("C", "")
)
unsignedb(
"Cursor_isVariadic",
"Returns non-zero if the given cursor is a variadic function or method.",
CXCursor("C", "")
)
unsignedb(
"Cursor_isExternalSymbol",
"Returns non-zero if the given cursor points to a symbol marked with external_source_symbol attribute.",
CXCursor("C", ""),
Check(1)..nullable..CXString.p("language", "if non-#NULL, and the attribute is present, will be set to the 'language' string from the attribute"),
Check(1)..nullable..CXString.p("definedIn", "if non-#NULL, and the attribute is present, will be set to the 'definedIn' string from the attribute"),
Check(1)..nullable..unsigned.p(
"isGenerated",
"if non-#NULL, and the attribute is present, will be set to non-zero if the 'generated_declaration' is set in the attribute"
)
)
CXSourceRange(
"Cursor_getCommentRange",
"""
Given a cursor that represents a declaration, return the associated comment's source range. The range may include multiple consecutive comments with
whitespace in between.
""",
CXCursor("C", "")
)
CXString(
"Cursor_getRawCommentText",
"Given a cursor that represents a declaration, return the associated comment text, including comment markers.",
CXCursor("C", "")
)
CXString(
"Cursor_getBriefCommentText",
"""
Given a cursor that represents a documentable entity (e.g., declaration), return the associated; otherwise return the
first paragraph.
""",
CXCursor("C", "")
)
CXString(
"Cursor_getMangling",
"Retrieve the {@code CXString} representing the mangled name of the cursor.",
CXCursor("cursor", "")
)
CXStringSet.p(
"Cursor_getCXXManglings",
"Retrieve the {@code CXString}s representing the mangled symbols of the C++ constructor or destructor at the cursor.",
CXCursor("cursor", "")
)
IgnoreMissing..CXStringSet.p(
"Cursor_getObjCManglings",
"Retrieve the {@code CXString}s representing the mangled symbols of the ObjC class interface or implementation at the cursor.",
CXCursor("cursor", "")
)
CXModule(
"Cursor_getModule",
"Given a #Cursor_ModuleImportDecl cursor, return the associated module.",
CXCursor("C", "")
)
CXModule(
"getModuleForFile",
"Given a {@code CXFile} header file, return the module that contains it, if one exists.",
CXTranslationUnit("TU", ""),
CXFile("file", "")
)
CXFile(
"Module_getASTFile",
"",
CXModule("Module", "a module object"),
returnDoc = "the module file where the provided module object came from"
)
CXModule(
"Module_getParent",
"",
CXModule("Module", "a module object"),
returnDoc = "the parent of a sub-module or #NULL if the given module is top-level, e.g. for 'std.vector' it will return the 'std' module."
)
CXString(
"Module_getName",
"",
CXModule("Module", "a module object"),
returnDoc = "the name of the module, e.g. for the 'std.vector' sub-module it will return \"vector\"."
)
CXString(
"Module_getFullName",
"",
CXModule("Module", "a module object"),
returnDoc = "the full name of the module, e.g. \"std.vector\"."
)
intb(
"Module_isSystem",
"",
CXModule("Module", "a module object"),
returnDoc = "non-zero if the module is a system one"
)
unsigned(
"Module_getNumTopLevelHeaders",
"",
CXTranslationUnit("TU", ""),
CXModule("Module", "a module object"),
returnDoc = "the number of top level headers associated with this module"
)
CXFile(
"Module_getTopLevelHeader",
"",
CXTranslationUnit("TU", ""),
CXModule("Module", "a module object"),
unsigned("Index", "top level header index (zero-based)"),
returnDoc = "the specified top level header associated with the module"
)
unsignedb(
"CXXConstructor_isConvertingConstructor",
"Determine if a C++ constructor is a converting constructor.",
CXCursor("C", "")
)
unsignedb(
"CXXConstructor_isCopyConstructor",
"Determine if a C++ constructor is a copy constructor.",
CXCursor("C", "")
)
unsignedb(
"CXXConstructor_isDefaultConstructor",
"Determine if a C++ constructor is the default constructor.",
CXCursor("C", "")
)
unsignedb(
"CXXConstructor_isMoveConstructor",
"Determine if a C++ constructor is a move constructor.",
CXCursor("C", "")
)
unsignedb(
"CXXField_isMutable",
"Determine if a C++ field is declared 'mutable'.",
CXCursor("C", "")
)
unsignedb(
"CXXMethod_isDefaulted",
"Determine if a C++ method is declared '= default'.",
CXCursor("C", "")
)
unsignedb(
"CXXMethod_isPureVirtual",
"Determine if a C++ member function or member function template is pure virtual.",
CXCursor("C", "")
)
unsignedb(
"CXXMethod_isStatic",
"Determine if a C++ member function or member function template is declared 'static'.",
CXCursor("C", "")
)
unsignedb(
"CXXMethod_isVirtual",
"""
Determine if a C++ member function or member function template is explicitly declared 'virtual' or if it overrides a virtual method from one of the
base classes.
""",
CXCursor("C", "")
)
IgnoreMissing..unsignedb(
"CXXRecord_isAbstract",
"Determine if a C++ record is abstract, i.e. whether a class or struct has a pure virtual member function.",
CXCursor("C", "")
)
unsignedb(
"EnumDecl_isScoped",
"Determine if an enum declaration refers to a scoped enum.",
CXCursor("C", "")
)
unsignedb(
"CXXMethod_isConst",
"Determine if a C++ member function or member function template is declared 'const'.",
CXCursor("C", "")
)
CXCursorKind(
"getTemplateCursorKind",
"""
Given a cursor that represents a template, determine the cursor kind of the specializations would be generated by instantiating the template.
This routine can be used to determine what flavor of function template, class template, or class template partial specialization is stored in the
cursor. For example, it can describe whether a class template cursor is declared with "struct", "class" or "union".
""",
CXCursor("C", "the cursor to query. This cursor should represent a template declaration."),
returnDoc =
"""
the cursor kind of the specializations that would be generated by instantiating the template {@code C}. If {@code C} is not a template, returns
#Cursor_NoDeclFound.
"""
)
CXCursor(
"getSpecializedCursorTemplate",
"""
Given a cursor that may represent a specialization or instantiation of a template, retrieve the cursor that represents the template that it specializes
or from which it was instantiated.
This routine determines the template involved both for explicit specializations of templates and for implicit instantiations of the template, both of
which are referred to as "specializations". For a class template specialization (e.g., {@code std::vector<bool>}), this routine will return either the
primary template ({@code std::vector}) or, if the specialization was instantiated from a class template partial specialization, the class template
partial specialization. For a class template partial specialization and a function template specialization (including instantiations), this this
routine will return the specialized template.
For members of a class template (e.g., member functions, member classes, or static data members), returns the specialized or instantiated member.
Although not strictly "templates" in the C++ language, members of class templates have the same notions of specializations and instantiations that
templates do, so this routine treats them similarly.
""",
CXCursor("C", "a cursor that may be a specialization of a template or a member of a template"),
returnDoc =
"""
if the given cursor is a specialization or instantiation of a template or a member thereof, the template or member that it specializes or from which it
was instantiated. Otherwise, returns a #NULL cursor.
"""
)
CXSourceRange(
"getCursorReferenceNameRange",
"Given a cursor that references something else, return the source range covering that reference.",
CXCursor("C", "a cursor pointing to a member reference, a declaration reference, or an operator call"),
unsigned(
"NameFlags",
"a bitset with three independent flags: #NameRange_WantQualifier, #NameRange_WantTemplateArgs, and #NameRange_WantSinglePiece"
),
unsigned(
"PieceIndex",
"""
for contiguous names or when passing the flag #NameRange_WantSinglePiece, only one piece with index 0 is available. When the
#NameRange_WantSinglePiece flag is not passed for a non-contiguous names, this index can be used to retrieve the individual pieces of the name.
See also #NameRange_WantSinglePiece.
"""
),
returnDoc =
"""
the piece of the name pointed to by the given cursor. If there is no name, or if the {@code PieceIndex} is out-of-range, a null-cursor will be
returned.
"""
)
IgnoreMissing..CXToken.p(
"getToken",
"Get the raw lexical token starting with the given location.",
CXTranslationUnit("TU", "the translation unit whose text is being tokenized"),
CXSourceLocation("Location", "the source location with which the token starts"),
returnDoc =
"""
the token starting with the given location or #NULL if no such token exist. The returned pointer must be freed with #disposeTokens() before the
translation unit is destroyed.
"""
)
CXTokenKind(
"getTokenKind",
"Determine the kind of the given token.",
CXToken("token", "")
)
CXString(
"getTokenSpelling",
"""
Determine the spelling of the given token.
The spelling of a token is the textual representation of that token, e.g., the text of an identifier or keyword.
""",
CXTranslationUnit("TU", ""),
CXToken("token", "")
)
CXSourceLocation(
"getTokenLocation",
"Retrieve the source location of the given token.",
CXTranslationUnit("TU", ""),
CXToken("token", "")
)
CXSourceRange(
"getTokenExtent",
"Retrieve a source range that covers the given token.",
CXTranslationUnit("TU", ""),
CXToken("token", "")
)
void(
"tokenize",
"Tokenize the source code described by the given range into raw lexical tokens.",
CXTranslationUnit("TU", "the translation unit whose text is being tokenized"),
CXSourceRange(
"Range",
"the source range in which text should be tokenized. All of the tokens produced by tokenization will fall within this source range,"
),
Check(1)..CXToken.p.p(
"Tokens",
"""
this pointer will be set to point to the array of tokens that occur within the given source range. The returned pointer must be freed with
#disposeTokens() before the translation unit is destroyed.
"""
),
Check(1)..unsigned.p("NumTokens", "will be set to the number of tokens in the {@code *Tokens} array")
)
void(
"annotateTokens",
"""
Annotate the given set of tokens by providing cursors for each token that can be mapped to a specific entity within the abstract syntax tree.
This token-annotation routine is equivalent to invoking #getCursor() for the source locations of each of the tokens. The cursors provided are filtered,
so that only those cursors that have a direct correspondence to the token are accepted. For example, given a function call {@code f(x)},
{@code clang_getCursor()} would provide the following cursors:
${ul(
"when the cursor is over the 'f', a DeclRefExpr cursor referring to 'f'.",
"when the cursor is over the '(' or the ')', a CallExpr referring to 'f'.",
"when the cursor is over the 'x', a DeclRefExpr cursor referring to 'x'."
)}
Only the first and last of these cursors will occur within the annotate, since the tokens "f" and "x' directly refer to a function and a variable,
respectively, but the parentheses are just a small part of the full syntax of the function call expression, which is not provided as an annotation.
""",
CXTranslationUnit("TU", "the translation unit that owns the given tokens"),
Input..CXToken.p("Tokens", "the set of tokens to annotate"),
AutoSize("Tokens", "Cursors")..unsigned("NumTokens", "the number of tokens in {@code Tokens}"),
CXCursor.p("Cursors", "an array of {@code NumTokens} cursors, whose contents will be replaced with the cursors corresponding to each token")
)
void(
"disposeTokens",
"Free the given set of tokens.",
CXTranslationUnit("TU", ""),
Input..CXToken.p("Tokens", ""),
AutoSize("Tokens")..unsigned("NumTokens", "")
)
CXString(
"getCursorKindSpelling",
"",
CXCursorKind("Kind", "")
)
void(
"getDefinitionSpellingAndExtent",
"",
CXCursor("cursor", ""),
Check(1)..nullable..char.const.p.p("startBuf", ""),
Check(1)..nullable..char.const.p.p("endBuf", ""),
Check(1)..nullable..unsigned.p("startLine", ""),
Check(1)..nullable..unsigned.p("startColumn", ""),
Check(1)..nullable..unsigned.p("endLine", ""),
Check(1)..nullable..unsigned.p("endColumn", "")
)
void("enableStackTraces", "", void())
void(
"executeOnThread",
"",
CXExecuteOnThread("fn", ""),
nullable..opaque_p("user_data", ""),
unsigned("stack_size", "")
)
CXCompletionChunkKind(
"getCompletionChunkKind",
"Determine the kind of a particular chunk within a completion string.",
CXCompletionString("completion_string", "the completion string to query"),
unsigned("chunk_number", "the 0-based index of the chunk in the completion string"),
returnDoc = "the kind of the chunk at the index {@code chunk_number}"
)
CXString(
"getCompletionChunkText",
"Retrieve the text associated with a particular chunk within a completion string.",
CXCompletionString("completion_string", "the completion string to query"),
unsigned("chunk_number", "the 0-based index of the chunk in the completion string"),
returnDoc = "the text associated with the chunk at index {@code chunk_number}"
)
CXCompletionString(
"getCompletionChunkCompletionString",
"Retrieve the completion string associated with a particular chunk within a completion string.",
CXCompletionString("completion_string", "the completion string to query"),
unsigned("chunk_number", "the 0-based index of the chunk in the completion string"),
returnDoc = "the completion string associated with the chunk at index {@code chunk_number}"
)
unsigned(
"getNumCompletionChunks",
"Retrieve the number of chunks in the given code-completion string.",
CXCompletionString("completion_string", "")
)
unsigned(
"getCompletionPriority",
"""
Determine the priority of this code completion.
The priority of a code completion indicates how likely it is that this particular completion is the completion that the user will select. The priority
is selected by various internal heuristics.
""",
CXCompletionString("completion_string", "the completion string to query"),
returnDoc = "the priority of this completion string. Smaller values indicate higher-priority (more likely) completions."
)
CXAvailabilityKind(
"getCompletionAvailability",
"Determine the availability of the entity that this code-completion string refers to.",
CXCompletionString("completion_string", "the completion string to query"),
returnDoc = "the availability of the completion string"
)
unsigned(
"getCompletionNumAnnotations",
"Retrieve the number of annotations associated with the given completion string.",
CXCompletionString("completion_string", "the completion string to query"),
returnDoc = "the number of annotations associated with the given completion string"
)
CXString(
"getCompletionAnnotation",
"Retrieve the annotation associated with the given completion string.",
CXCompletionString("completion_string", "the completion string to query"),
unsigned("annotation_number", "the 0-based index of the annotation of the completion string"),
returnDoc = "annotation string associated with the completion at index {@code annotation_number}, or a #NULL string if that annotation is not available"
)
CXString(
"getCompletionParent",
"""
Retrieve the parent context of the given completion string.
The parent context of a completion string is the semantic parent of the declaration (if any) that the code completion represents. For example, a code
completion for an Objective-C method would have the method's class or protocol as its context.
""",
CXCompletionString("completion_string", "the code completion string whose parent is being queried"),
Check(1)..nullable..CXCursorKind.p("kind", "DEPRECATED: always set to #Cursor_NotImplemented if non-#NULL"),
returnDoc = "the name of the completion parent, e.g., \"NSObject\" if the completion string represents a method in the {@code NSObject} class."
)
CXString(
"getCompletionBriefComment",
"Retrieve the brief documentation comment attached to the declaration that corresponds to the given completion string.",
CXCompletionString("completion_string", "")
)
CXCompletionString(
"getCursorCompletionString",
"Retrieve a completion string for an arbitrary declaration or macro definition cursor.",
CXCursor("cursor", "the cursor to query"),
returnDoc = "a non-context-sensitive completion string for declaration and macro definition cursors, or #NULL for other kinds of cursors"
)
IgnoreMissing..unsigned(
"getCompletionNumFixIts",
"""
Retrieve the number of fix-its for the given completion index.
Calling this makes sense only if #CodeComplete_IncludeCompletionsWithFixIts option was set.
""",
CXCodeCompleteResults.p("results", "the structure keeping all completion results"),
unsigned("completion_index", "the index of the completion"),
returnDoc = "the number of fix-its which must be applied before the completion at {@code completion_index} can be applied"
)
IgnoreMissing..CXString(
"getCompletionFixIt",
"""
Fix-its that <b>must</b> be applied before inserting the text for the corresponding completion.
By default, #codeCompleteAt() only returns completions with empty fix-its. Extra completions with non-empty fix-its should be explicitly requested
by setting #CodeComplete_IncludeCompletionsWithFixIts.
For the clients to be able to compute position of the cursor after applying fix-its, the following conditions are guaranteed to hold for
{@code replacement_range} of the stored fix-its:
${ul(
"""
Ranges in the fix-its are guaranteed to never contain the completion point (or identifier under completion point, if any) inside them, except at
the start or at the end of the range.
""",
"""
If a fix-it range starts or ends with completion point (or starts or ends after the identifier under completion point), it will contain at least
one character. It allows to unambiguously recompute completion point after applying the fix-it.
"""
)}
The intuition is that provided fix-its change code around the identifier we complete, but are not allowed to touch the identifier itself or the
completion point. One example of completions with corrections are the ones replacing '.' with '->' and vice versa:
{@code std::unique_ptr<std::vector<int>> vec_ptr;} In 'vec_ptr.^', one of the completions is 'push_back', it requires replacing '.' with '->'. In
'vec_ptr->^', one of the completions is 'release', it requires replacing '->' with '.'.
""",
CXCodeCompleteResults.p("results", "the structure keeping all completion results"),
unsigned("completion_index", "the index of the completion"),
unsigned("fixit_index", "the index of the fix-it for the completion at {@code completion_index}"),
CXSourceRange.p("replacement_range", "the fix-it range that must be replaced before the completion at completion_index can be applied"),
returnDoc = "the fix-it string that must replace the code at replacement_range before the completion at completion_index can be applied"
)
unsigned("defaultCodeCompleteOptions", "Returns a default set of code-completion options that can be passed to #codeCompleteAt().", void())
CXCodeCompleteResults.p(
"codeCompleteAt",
"""
Perform code completion at a given location in a translation unit.
This function performs code completion at a particular file, line, and column within source code, providing results that suggest potential code
snippets based on the context of the completion. The basic model for code completion is that Clang will parse a complete source file, performing syntax
checking up to the location where code-completion has been requested. At that point, a special code-completion token is passed to the parser, which
recognizes this token and determines, based on the current location in the C/Objective-C/C++ grammar and the state of semantic analysis, what
completions to provide. These completions are returned via a new {@code CXCodeCompleteResults} structure.
Code completion itself is meant to be triggered by the client when the user types punctuation characters or whitespace, at which point the
code-completion location will coincide with the cursor. For example, if {@code p} is a pointer, code-completion might be triggered after the "-" and
then after the ">" in {@code p->}. When the code-completion location is after the ">", the completion results will provide, e.g., the members of
the struct that "p" points to. The client is responsible for placing the cursor at the beginning of the token currently being typed, then filtering the
results based on the contents of the token. For example, when code-completing for the expression {@code p->get}, the client should provide the location
just after the ">" (e.g., pointing at the "g") to this code-completion hook. Then, the client can filter the results based on the current token text
("get"), only showing those results that start with "get". The intent of this interface is to separate the relatively high-latency acquisition of
code-completion results from the filtering of results on a per-character basis, which must have a lower latency.
""",
CXTranslationUnit(
"TU",
"""
the translation unit in which code-completion should occur. The source files for this translation unit need not be completely up-to-date (and the
contents of those source files may be overridden via {@code unsaved_files}). Cursors referring into the translation unit may be invalidated by this
invocation.
"""
),
charUTF8.const.p(
"complete_filename",
"the name of the source file where code completion should be performed. This filename may be any file included in the translation unit."
),
unsigned("complete_line", "the line at which code-completion should occur"),
unsigned(
"complete_column",
"""
the column at which code-completion should occur. Note that the column should point just after the syntactic construct that initiated code
completion, and not in the middle of a lexical token.
"""
),
nullable..CXUnsavedFile.p(
"unsaved_files",
"""
the Files that have not yet been saved to disk but may be required for parsing or code completion, including the contents of those files. The
contents and name of these files (as specified by {@code CXUnsavedFile}) are copied when necessary, so the client only needs to guarantee their
validity until the call to this function returns.
"""
),
AutoSize("unsaved_files")..unsigned("num_unsaved_files", "the number of unsaved file entries in {@code unsaved_files}"),
unsigned(
"options",
"""
extra options that control the behavior of code completion, expressed as a bitwise OR of the enumerators of the {@code CXCodeComplete_Flags}
enumeration. The #defaultCodeCompleteOptions() function returns a default set of code-completion options.
"""
),
returnDoc =
"""
if successful, a new {@code CXCodeCompleteResults} structure containing code-completion results, which should eventually be freed with
#disposeCodeCompleteResults(). If code completion fails, returns #NULL.
"""
)
void(
"sortCodeCompletionResults",
"Sort the code-completion results in case-insensitive alphabetical order.",
CXCompletionResult.p("Results", "the set of results to sort"),
AutoSize("Results")..unsigned("NumResults", "the number of results in {@code Results}")
)
void(
"disposeCodeCompleteResults",
"Free the given set of code-completion results.",
CXCodeCompleteResults.p("Results", "")
)
unsigned(
"codeCompleteGetNumDiagnostics",
"Determine the number of diagnostics produced prior to the location where code completion was performed.",
CXCodeCompleteResults.p("Results", "")
)
CXDiagnostic(
"codeCompleteGetDiagnostic",
"Retrieve a diagnostic associated with the given code completion.",
CXCodeCompleteResults.p("Results", "the code completion results to query"),
unsigned("Index", "the zero-based diagnostic number to retrieve"),
returnDoc = "the requested diagnostic. This diagnostic must be freed via a call to #disposeDiagnostic()."
)
unsigned_long_long(
"codeCompleteGetContexts",
"Determines what completions are appropriate for the context the given code completion.",
CXCodeCompleteResults.p("Results", "the code completion results to query"),
returnDoc = "the kinds of completions that are appropriate for use along with the given code completion results"
)
CXCursorKind(
"codeCompleteGetContainerKind",
"""
Returns the cursor kind for the container for the current code completion context. The container is only guaranteed to be set for contexts where a
container exists (i.e. member accesses or Objective-C message sends); if there is not a container, this function will return #Cursor_InvalidCode.
""",
CXCodeCompleteResults.p("Results", "the code completion results to query"),
Check(1)..unsigned.p(
"IsIncomplete",
"""
on return, this value will be false if Clang has complete information about the container. If Clang does not have complete information, this value
will be true.
"""
),
returnDoc = "the container kind, or #Cursor_InvalidCode if there is not a container"
)
CXString(
"codeCompleteGetContainerUSR",
"""
Returns the USR for the container for the current code completion context. If there is not a container for the current context, this function will
return the empty string.
""",
CXCodeCompleteResults.p("Results", "the code completion results to query"),
returnDoc = "the USR for the container"
)
CXString(
"codeCompleteGetObjCSelector",
"""
Returns the currently-entered selector for an Objective-C message send, formatted like "initWithFoo:bar:". Only guaranteed to return a non-empty string
for #CompletionContext_ObjCInstanceMessage and #CompletionContext_ObjCClassMessage.
""",
CXCodeCompleteResults.p("Results", "the code completion results to query"),
returnDoc = "the selector (or partial selector) that has been entered thus far for an Objective-C message send"
)
CXString(
"getClangVersion",
"Return a version string, suitable for showing to a user, but not intended to be parsed (the format is not guaranteed to be stable).",
void()
)
void(
"toggleCrashRecovery",
"Enable/disable crash recovery.",
unsignedb("isEnabled", "flag to indicate if crash recovery is enabled. A non-zero value enables crash recovery, while 0 disables it.")
)
void(
"getInclusions",
"""
Visit the set of preprocessor inclusions in a translation unit. The visitor function is called with the provided data for every included file. This
does not include headers included by the PCH file (unless one is inspecting the inclusions in the PCH file itself).
""",
CXTranslationUnit("tu", ""),
CXInclusionVisitor("visitor", ""),
nullable..CXClientData("client_data", "")
)
CXEvalResult(
"Cursor_Evaluate",
"""
If cursor is a statement declaration tries to evaluate the statement and if its variable, tries to evaluate its initializer, into its corresponding
type.
If it's an expression, tries to evaluate the expression.
""",
CXCursor("C", "")
)
CXEvalResultKind(
"EvalResult_getKind",
"Returns the kind of the evaluated result.",
CXEvalResult("E", "")
)
int(
"EvalResult_getAsInt",
"Returns the evaluation result as integer if the kind is Int.",
CXEvalResult("E", "")
)
long_long(
"EvalResult_getAsLongLong",
"""
Returns the evaluation result as a long long integer if the kind is Int. This prevents overflows that may happen if the result is returned with
#EvalResult_getAsInt().
""",
CXEvalResult("E", "")
)
unsignedb(
"EvalResult_isUnsignedInt",
"Returns a non-zero value if the kind is Int and the evaluation result resulted in an unsigned integer.",
CXEvalResult("E", "")
)
unsigned_long_long(
"EvalResult_getAsUnsigned",
"Returns the evaluation result as an unsigned integer if the kind is Int and #EvalResult_isUnsignedInt() is non-zero.",
CXEvalResult("E", "")
)
double(
"EvalResult_getAsDouble",
"Returns the evaluation result as double if the kind is double.",
CXEvalResult("E", "")
)
charUTF8.const.p(
"EvalResult_getAsStr",
"""
Returns the evaluation result as a constant string if the kind is other than Int or float. User must not free this pointer, instead call
#EvalResult_dispose() on the {@code CXEvalResult} returned by #Cursor_Evaluate().
""",
CXEvalResult("E", "")
)
void(
"EvalResult_dispose",
"Disposes the created {@code Eval} memory.",
CXEvalResult("E", "")
)
CXRemapping(
"getRemappings",
"Retrieve a remapping.",
charUTF8.const.p("path", "the path that contains metadata about remappings"),
returnDoc = "the requested remapping. This remapping must be freed via a call to #remap_dispose(). Can return #NULL if an error occurred."
)
CXRemapping(
"getRemappingsFromFileList",
"Retrieve a remapping.",
charUTF8.const.p.p("filePaths", "pointer to an array of file paths containing remapping info"),
AutoSize("filePaths")..unsigned("numFiles", "number of file paths"),
returnDoc = "the requested remapping. This remapping must be freed via a call to #remap_dispose(). Can return #NULL if an error occurred."
)
unsigned(
"remap_getNumFiles",
"Determine the number of remappings.",
CXRemapping("Remapping", "")
)
void(
"remap_getFilenames",
"Get the original and the associated filename from the remapping.",
CXRemapping("Remapping", ""),
unsigned("index", ""),
nullable..CXString.p("original", "if non-#NULL, will be set to the original filename"),
nullable..CXString.p("transformed", "if non-#NULL, will be set to the filename that the original is associated with")
)
void(
"remap_dispose",
"Dispose the remapping.",
CXRemapping("Remapping", "")
)
CXResult(
"findReferencesInFile",
"Find references of a declaration in a specific file.",
CXCursor("cursor", "pointing to a declaration or a reference of one"),
CXFile("file", "to search for references"),
CXCursorAndRangeVisitor(
"visitor",
"""
callback that will receive pairs of {@code CXCursor/CXSourceRange} for each reference found. The {@code CXSourceRange} will point inside the file;
if the reference is inside a macro (and not a macro argument) the {@code CXSourceRange} will be invalid.
"""
),
returnDoc = "one of the {@code CXResult} enumerators"
)
CXResult(
"findIncludesInFile",
"Find {@code \\#import/\\#include} directives in a specific file.",
CXTranslationUnit("TU", "translation unit containing the file to query"),
CXFile("file", "to search for {@code \\#import/\\#include} directives"),
CXCursorAndRangeVisitor("visitor", "callback that will receive pairs of {@code CXCursor/CXSourceRange} for each directive found"),
returnDoc = "one of the CXResult enumerators"
)
intb(
"index_isEntityObjCContainerKind",
"",
CXIdxEntityKind("kind", "")
)
CXIdxObjCContainerDeclInfo.const.p(
"index_getObjCContainerDeclInfo",
"",
CXIdxDeclInfo.const.p("info", "")
)
CXIdxObjCInterfaceDeclInfo.const.p(
"index_getObjCInterfaceDeclInfo",
"",
CXIdxDeclInfo.const.p("info", "")
)
CXIdxObjCCategoryDeclInfo.const.p(
"index_getObjCCategoryDeclInfo",
"",
CXIdxDeclInfo.const.p("info", "")
)
CXIdxObjCProtocolRefListInfo.const.p(
"index_getObjCProtocolRefListInfo",
"",
CXIdxDeclInfo.const.p("info", "")
)
CXIdxObjCPropertyDeclInfo.const.p(
"index_getObjCPropertyDeclInfo",
"",
CXIdxDeclInfo.const.p("info", "")
)
CXIdxIBOutletCollectionAttrInfo.const.p(
"index_getIBOutletCollectionAttrInfo",
"",
CXIdxAttrInfo.const.p("info", "")
)
CXIdxCXXClassDeclInfo.const.p(
"index_getCXXClassDeclInfo",
"",
CXIdxDeclInfo.const.p("info", "")
)
CXIdxClientContainer(
"index_getClientContainer",
"For retrieving a custom {@code CXIdxClientContainer} attached to a container.",
CXIdxContainerInfo.const.p("info", "")
)
void(
"index_setClientContainer",
"For setting a custom {@code CXIdxClientContainer} attached to a container.",
CXIdxContainerInfo.const.p("info", ""),
CXIdxClientContainer("container", "")
)
CXIdxClientEntity(
"index_getClientEntity",
"For retrieving a custom {@code CXIdxClientEntity} attached to an entity.",
CXIdxEntityInfo.const.p("info", "")
)
void(
"index_setClientEntity",
"For setting a custom {@code CXIdxClientEntity} attached to an entity.",
CXIdxEntityInfo.const.p("info", ""),
CXIdxClientEntity("entity", "")
)
CXIndexAction(
"IndexAction_create",
"An indexing action/session, to be applied to one or multiple translation units.",
CXIndex("CIdx", "the index object with which the index action will be associated")
)
void(
"IndexAction_dispose",
"""
Destroy the given index action.
The index action must not be destroyed until all of the translation units created within that index action have been destroyed.
""",
CXIndexAction("action", "")
)
int(
"indexSourceFile",
"""
Index the given source file and the translation unit corresponding to that file via callbacks implemented through ##IndexerCallbacks.
The rest of the parameters are the same as #parseTranslationUnit().
""",
CXIndexAction("action", ""),
nullable..CXClientData("client_data", "pointer data supplied by the client, which will be passed to the invoked callbacks"),
IndexerCallbacks.p("index_callbacks", "pointer to indexing callbacks that the client implements"),
unsigned("index_callbacks_size", "size of ##IndexerCallbacks structure that gets passed in {@code index_callbacks}"),
unsigned(
"index_options",
"a bitmask of options that affects how indexing is performed. This should be a bitwise OR of the {@code CXIndexOpt_XXX} flags."
),
charUTF8.const.p("source_filename", ""),
nullable..charUTF8.const.p.const.p("command_line_args", ""),
AutoSize("command_line_args")..int("num_command_line_args", ""),
nullable..CXUnsavedFile.p("unsaved_files", ""),
AutoSize("unsaved_files")..unsigned("num_unsaved_files", ""),
Check(1)..nullable..CXTranslationUnit.p(
"out_TU",
"pointer to store a {@code CXTranslationUnit} that can be reused after indexing is finished. Set to #NULL if you do not require it."
),
unsigned("TU_options", ""),
returnDoc =
"""
0 on success or if there were errors from which the compiler could recover. If there is a failure from which there is no recovery, returns a non-zero
{@code CXErrorCode}.
"""
)
int(
"indexSourceFileFullArgv",
"""
Same as #indexSourceFile() but requires a full command line for {@code command_line_args} including {@code argv[0]}. This is useful if the standard
library paths are relative to the binary.
""",
CXIndexAction("action", ""),
nullable..CXClientData("client_data", ""),
IndexerCallbacks.p("index_callbacks", ""),
unsigned("index_callbacks_size", ""),
unsigned("index_options", ""),
charUTF8.const.p("source_filename", ""),
charUTF8.const.p.const.p("command_line_args", ""),
AutoSize("command_line_args")..int("num_command_line_args", ""),
nullable..CXUnsavedFile.p("unsaved_files", ""),
AutoSize("unsaved_files")..unsigned("num_unsaved_files", ""),
Check(1)..nullable..CXTranslationUnit.p("out_TU", ""),
unsigned("TU_options", "")
)
intb(
"indexTranslationUnit",
"""
Index the given translation unit via callbacks implemented through ##IndexerCallbacks.
The order of callback invocations is not guaranteed to be the same as when indexing a source file. The high level order will be:
${ul(
"Preprocessor callbacks invocations",
"Declaration/reference callbacks invocations",
"Diagnostic callback invocations"
)}
The parameters are the same as #indexSourceFile().
""",
CXIndexAction("action", ""),
nullable..CXClientData("client_data", ""),
IndexerCallbacks.p("index_callbacks", ""),
unsigned("index_callbacks_size", ""),
unsigned("index_options", ""),
CXTranslationUnit("TU", ""),
returnDoc = "if there is a failure from which there is no recovery, returns non-zero, otherwise returns 0"
)
void(
"indexLoc_getFileLocation",
"""
Retrieve the {@code CXIdxFile}, file, line, column, and offset represented by the given {@code CXIdxLoc}.
If the location refers into a macro expansion, retrieves the location of the macro expansion and if it refers into a macro argument retrieves the
location of the argument.
""",
CXIdxLoc("loc", ""),
Check(1)..nullable..CXIdxClientFile.p("indexFile", ""),
Check(1)..nullable..CXFile.p("file", ""),
Check(1)..nullable..unsigned.p("line", ""),
Check(1)..nullable..unsigned.p("column", ""),
Check(1)..nullable..unsigned.p("offset", "")
)
CXSourceLocation(
"indexLoc_getCXSourceLocation",
"Retrieve the {@code CXSourceLocation} represented by the given {@code CXIdxLoc}.",
CXIdxLoc("loc", "")
)
unsignedb(
"Type_visitFields",
"""
Visit the fields of a particular type.
This function visits all the direct fields of the given cursor, invoking the given {@code visitor} function with the cursors of each visited field. The
traversal may be ended prematurely, if the visitor returns #Visit_Break.
""",
CXType("T", "the record type whose field may be visited"),
CXFieldVisitor("visitor", "the visitor function that will be invoked for each field of {@code T}"),
nullable..CXClientData(
"client_data",
"pointer data supplied by the client, which will be passed to the visitor each time it is invoked"
),
returnDoc = "a non-zero value if the traversal was terminated prematurely by the visitor returning #Visit_Break"
)
} | modules/lwjgl/llvm/src/templates/kotlin/llvm/templates/ClangIndex.kt | 3776983188 |
/*
* Copyright LWJGL. All rights reserved.
* License terms: https://www.lwjgl.org/license
*/
package opengles.templates
import org.lwjgl.generator.*
import opengles.*
val EXT_multisampled_render_to_texture = "EXTMultisampledRenderToTexture".nativeClassGLES("EXT_multisampled_render_to_texture", postfix = EXT) {
documentation =
"""
Native bindings to the $registryLink extension.
This extension introduces functionality to perform multisampled rendering to a color renderable texture, without requiring an explicit resolve of
multisample data.
Some GPU architectures - such as tile-based renderers - are capable of performing multisampled rendering by storing multisample data in internal
high-speed memory and downsampling the data when writing out to external memory after rendering has finished. Since per-sample data is never written
out to external memory, this approach saves bandwidth and storage space. In this case multisample data gets discarded, however this is acceptable in
most cases.
The extension provides a new command, FramebufferTexture2DMultisampleEXT, which attaches a texture level to a framebuffer and enables multisampled
rendering to that texture level.
When the texture level is flushed or used as a source or destination for any operation other than drawing to it, an implicit resolve of multisampled
color data may be performed. After such a resolve, the multisampled color data is discarded.
In order to allow the use of multisampled depth and stencil buffers when performing multisampled rendering to a texture, the extension also adds the
command RenderbufferStorageMultisampleEXT.
Requires ${GLES20.core}.
"""
IntConstant(
"Accepted by the {@code pname} parameter of GetRenderbufferParameteriv.",
"RENDERBUFFER_SAMPLES_EXT"..0x8CAB
)
IntConstant(
"Returned by CheckFramebufferStatus.",
"FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT"..0x8D56
)
IntConstant(
"Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, and GetFloatv.",
"MAX_SAMPLES_EXT"..0x8D57
)
IntConstant(
"Accepted by the {@code pname} parameter of GetFramebufferAttachmentParameteriv.",
"FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT"..0x8D6C
)
void(
"RenderbufferStorageMultisampleEXT",
"",
GLenum("target", ""),
GLsizei("samples", ""),
GLenum("internalformat", ""),
GLsizei("width", ""),
GLsizei("height", "")
)
void(
"FramebufferTexture2DMultisampleEXT",
"",
GLenum("target", ""),
GLenum("attachment", ""),
GLenum("textarget", ""),
GLuint("texture", ""),
GLint("level", ""),
GLsizei("samples", "")
)
} | modules/lwjgl/opengles/src/templates/kotlin/opengles/templates/EXT_multisampled_render_to_texture.kt | 461739990 |
/*
* Copyright LWJGL. All rights reserved.
* License terms: https://www.lwjgl.org/license
*/
package opengl.templates
import org.lwjgl.generator.*
import opengl.*
val GL21 = "GL21".nativeClassGL("GL21") {
extends = GL20
documentation =
"""
The OpenGL functionality up to version 2.1. Includes the deprecated symbols of the Compatibility Profile.
OpenGL 2.1 implementations must support at least revision 1.20 of the OpenGL Shading Language.
Extensions promoted to core in this release:
${ul(
registryLinkTo("ARB", "pixel_buffer_object"),
registryLinkTo("EXT", "texture_sRGB")
)}
"""
IntConstant(
"Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev.",
"CURRENT_RASTER_SECONDARY_COLOR"..0x845F
)
IntConstant(
"Returned by the {@code type} parameter of GetActiveUniform.",
"FLOAT_MAT2x3"..0x8B65,
"FLOAT_MAT2x4"..0x8B66,
"FLOAT_MAT3x2"..0x8B67,
"FLOAT_MAT3x4"..0x8B68,
"FLOAT_MAT4x2"..0x8B69,
"FLOAT_MAT4x3"..0x8B6A
)
reuse(GL21C, "UniformMatrix2x3fv")
reuse(GL21C, "UniformMatrix3x2fv")
reuse(GL21C, "UniformMatrix2x4fv")
reuse(GL21C, "UniformMatrix4x2fv")
reuse(GL21C, "UniformMatrix3x4fv")
reuse(GL21C, "UniformMatrix4x3fv")
// ARB_pixel_buffer_object
IntConstant(
"""
Accepted by the {@code target} parameters of BindBuffer, BufferData, BufferSubData, MapBuffer, UnmapBuffer, GetBufferSubData, GetBufferParameteriv, and
GetBufferPointerv.
""",
"PIXEL_PACK_BUFFER"..0x88EB,
"PIXEL_UNPACK_BUFFER"..0x88EC
)
IntConstant(
"Accepted by the {@code pname} parameter of GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev.",
"PIXEL_PACK_BUFFER_BINDING"..0x88ED,
"PIXEL_UNPACK_BUFFER_BINDING"..0x88EF
)
// EXT_texture_sRGB
IntConstant(
"Accepted by the {@code internalformat} parameter of TexImage1D, TexImage2D, TexImage3D, CopyTexImage1D, CopyTexImage2D.",
"SRGB"..0x8C40,
"SRGB8"..0x8C41,
"SRGB_ALPHA"..0x8C42,
"SRGB8_ALPHA8"..0x8C43,
"SLUMINANCE_ALPHA"..0x8C44,
"SLUMINANCE8_ALPHA8"..0x8C45,
"SLUMINANCE"..0x8C46,
"SLUMINANCE8"..0x8C47,
"COMPRESSED_SRGB"..0x8C48,
"COMPRESSED_SRGB_ALPHA"..0x8C49,
"COMPRESSED_SLUMINANCE"..0x8C4A,
"COMPRESSED_SLUMINANCE_ALPHA"..0x8C4B
)
} | modules/lwjgl/opengl/src/templates/kotlin/opengl/templates/GL21.kt | 2125058851 |
/*
* Copyright LWJGL. All rights reserved.
* License terms: https://www.lwjgl.org/license
*/
package opengl.templates
import org.lwjgl.generator.*
import opengl.*
val ARB_gl_spirv = "ARBGLSPIRV".nativeClassGL("ARB_gl_spirv") {
documentation =
"""
Native bindings to the $registryLink extension.
This is version 100 of the GL_ARB_gl_spirv extension.
This extension does two things:
${ol(
"""
Allows a SPIR-V module to be specified as containing a programmable shader stage, rather than using GLSL, whatever the source language was used to
create the SPIR-V module.
""",
"""
Modifies GLSL to be a source language for creating SPIR-V modules for OpenGL consumption. Such GLSL can be used to create such SPIR-V modules,
outside of the OpenGL runtime.
"""
)}
Requires ${GL33.core}.
"""
IntConstant(
"Accepted by the {@code binaryformat} parameter of #ShaderBinary().",
"SHADER_BINARY_FORMAT_SPIR_V_ARB"..0x9551
)
IntConstant(
"Accepted by the {@code pname} parameter of #GetShaderiv().",
"SPIR_V_BINARY_ARB"..0x9552
)
void(
"SpecializeShaderARB",
"""
Specializes a shader created from a SPIR-V module.
Shaders associated with SPIR-V modules must be specialized before they can be linked into a program object. It is not necessary to specialize the
shader before it is attached to a program object. Once specialized, a shader may not be specialized again without first re-associating the original
SPIR-V module with it, through #ShaderBinary().
Specialization does two things:
${ul(
"Selects the name of the entry point, for that shader’s stage, from the SPIR-V module.",
"Sets the values of all, or a subset of, the specialization constants in the SPIRV module."
)}
On successful shader specialization, the compile status for shader is set to #TRUE. On failure, the compile status for shader is set to #FALSE and
additional information about the cause of the failure may be available in the shader compilation log.
""",
GLuint(
"shader",
"""
the name of a shader object containing unspecialized SPIR-V as created from a successful call to #ShaderBinary() to which a SPIR-V module was
passed
"""
),
GLcharUTF8.const.p(
"pEntryPoint",
"a pointer to a null-terminated UTF-8 string specifying the name of the entry point in the SPIR-V module to use for this shader"
),
AutoSize("pConstantIndex", "pConstantValue")..GLuint(
"numSpecializationConstants",
"the number of specialization constants whose values to set in this call"
),
GLuint.const.p(
"pConstantIndex",
"""
is a pointer to an array of {@code numSpecializationConstants} unsigned integers, each holding the index of a specialization constant in the SPIR-V
module whose value to set.
Specialization constants not referenced by {@code pConstantIndex} retain their default values as specified in the SPIR-V module.
"""
),
GLuint.const.p(
"pConstantValue",
"""
an entry in {@code pConstantValue} is used to set the value of the specialization constant indexed by the corresponding entry in
{@code pConstantIndex}.
Although this array is of unsigned integer, each entry is bitcast to the appropriate type for the module, and therefore, floating-point constants
may be set by including their IEEE-754 bit representation in the {@code pConstantValue} array.
"""
)
)
} | modules/lwjgl/opengl/src/templates/kotlin/opengl/templates/ARB_gl_spirv.kt | 4286592888 |
// Copyright 2000-2018 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.
package com.intellij.configurationStore
import com.intellij.openapi.components.PathMacroManager
import com.intellij.openapi.components.PathMacroSubstitutor
import com.intellij.openapi.components.RoamingType
import com.intellij.openapi.components.StateStorage
import com.intellij.openapi.components.impl.stores.FileStorageCoreUtil
import com.intellij.openapi.diagnostic.debug
import com.intellij.openapi.diagnostic.runAndLogException
import com.intellij.openapi.util.JDOMUtil
import com.intellij.openapi.util.SystemInfoRt
import com.intellij.openapi.util.io.BufferExposingByteArrayOutputStream
import com.intellij.openapi.vfs.safeOutputStream
import com.intellij.util.LineSeparator
import com.intellij.util.SmartList
import com.intellij.util.containers.SmartHashSet
import com.intellij.util.io.delete
import com.intellij.util.loadElement
import gnu.trove.THashMap
import org.jdom.Attribute
import org.jdom.Element
import java.io.FileNotFoundException
import java.io.OutputStream
import java.io.Writer
import java.nio.file.Path
abstract class XmlElementStorage protected constructor(val fileSpec: String,
protected val rootElementName: String?,
private val pathMacroSubstitutor: PathMacroSubstitutor? = null,
roamingType: RoamingType? = RoamingType.DEFAULT,
private val provider: StreamProvider? = null) : StorageBaseEx<StateMap>() {
val roamingType: RoamingType = roamingType ?: RoamingType.DEFAULT
protected abstract fun loadLocalData(): Element?
final override fun getSerializedState(storageData: StateMap, component: Any?, componentName: String, archive: Boolean): Element? = storageData.getState(componentName, archive)
override fun archiveState(storageData: StateMap, componentName: String, serializedState: Element?) {
storageData.archive(componentName, serializedState)
}
override fun hasState(storageData: StateMap, componentName: String): Boolean = storageData.hasState(componentName)
override fun loadData(): StateMap = loadElement()?.let { loadState(it) } ?: StateMap.EMPTY
private fun loadElement(useStreamProvider: Boolean = true): Element? {
var element: Element? = null
try {
val isLoadLocalData: Boolean
if (useStreamProvider && provider != null) {
isLoadLocalData = !provider.read(fileSpec, roamingType) { inputStream ->
inputStream?.let {
element = loadElement(inputStream)
providerDataStateChanged(createDataWriterForElement(element!!), DataStateChanged.LOADED)
}
}
}
else {
isLoadLocalData = true
}
if (isLoadLocalData) {
element = loadLocalData()
}
}
catch (e: FileNotFoundException) {
throw e
}
catch (e: Throwable) {
LOG.error("Cannot load data for $fileSpec", e)
}
return element
}
protected open fun providerDataStateChanged(writer: DataWriter?, type: DataStateChanged) {
}
private fun loadState(element: Element): StateMap {
beforeElementLoaded(element)
return StateMap.fromMap(FileStorageCoreUtil.load(element, pathMacroSubstitutor))
}
fun setDefaultState(element: Element) {
element.name = rootElementName!!
storageDataRef.set(loadState(element))
}
override fun createSaveSessionProducer(): StateStorage.SaveSessionProducer? = if (checkIsSavingDisabled()) null else createSaveSession(getStorageData())
protected abstract fun createSaveSession(states: StateMap): StateStorage.SaveSessionProducer
override fun analyzeExternalChangesAndUpdateIfNeed(componentNames: MutableSet<in String>) {
val oldData = storageDataRef.get()
val newData = getStorageData(true)
if (oldData == null) {
LOG.debug { "analyzeExternalChangesAndUpdateIfNeed: old data null, load new for ${toString()}" }
componentNames.addAll(newData.keys())
}
else {
val changedComponentNames = oldData.getChangedComponentNames(newData)
LOG.debug { "analyzeExternalChangesAndUpdateIfNeed: changedComponentNames $changedComponentNames for ${toString()}" }
if (changedComponentNames.isNotEmpty()) {
componentNames.addAll(changedComponentNames)
}
}
}
private fun setStates(oldStorageData: StateMap, newStorageData: StateMap?) {
if (oldStorageData !== newStorageData && storageDataRef.getAndSet(newStorageData) !== oldStorageData) {
LOG.warn("Old storage data is not equal to current, new storage data was set anyway")
}
}
abstract class XmlElementStorageSaveSession<T : XmlElementStorage>(private val originalStates: StateMap, protected val storage: T) : SaveSessionBase() {
private var copiedStates: MutableMap<String, Any>? = null
private val newLiveStates = THashMap<String, Element>()
override fun createSaveSession(): XmlElementStorageSaveSession<T>? = if (copiedStates == null || storage.checkIsSavingDisabled()) null else this
override fun setSerializedState(componentName: String, element: Element?) {
val normalized = element?.normalizeRootName()
if (copiedStates == null) {
copiedStates = setStateAndCloneIfNeed(componentName, normalized, originalStates, newLiveStates)
}
else {
updateState(copiedStates!!, componentName, normalized, newLiveStates)
}
}
override fun save() {
val stateMap = StateMap.fromMap(copiedStates!!)
val elements = save(stateMap, newLiveStates)
val writer: DataWriter?
if (elements == null) {
writer = null
}
else {
val rootAttributes = LinkedHashMap<String, String>()
storage.beforeElementSaved(elements, rootAttributes)
val macroManager = if (storage.pathMacroSubstitutor == null) null else (storage.pathMacroSubstitutor as TrackingPathMacroSubstitutorImpl).macroManager
writer = XmlDataWriter(storage.rootElementName, elements, rootAttributes, macroManager)
}
// during beforeElementSaved() elements can be modified and so, even if our save() never returns empty list, at this point, elements can be an empty list
var isSavedLocally = false
val provider = storage.provider
if (elements == null) {
if (provider == null || !provider.delete(storage.fileSpec, storage.roamingType)) {
isSavedLocally = true
saveLocally(writer)
}
}
else if (provider != null && provider.isApplicable(storage.fileSpec, storage.roamingType)) {
// we should use standard line-separator (\n) - stream provider can share file content on any OS
provider.write(storage.fileSpec, writer!!.toBufferExposingByteArray(), storage.roamingType)
}
else {
isSavedLocally = true
saveLocally(writer)
}
if (!isSavedLocally) {
storage.providerDataStateChanged(writer, DataStateChanged.SAVED)
}
storage.setStates(originalStates, stateMap)
}
protected abstract fun saveLocally(dataWriter: DataWriter?)
}
protected open fun beforeElementLoaded(element: Element) {
}
protected open fun beforeElementSaved(elements: MutableList<Element>, rootAttributes: MutableMap<String, String>) {
}
fun updatedFromStreamProvider(changedComponentNames: MutableSet<String>, deleted: Boolean) {
updatedFrom(changedComponentNames, deleted, true)
}
fun updatedFrom(changedComponentNames: MutableSet<String>, deleted: Boolean, useStreamProvider: Boolean) {
if (roamingType == RoamingType.DISABLED) {
// storage roaming was changed to DISABLED, but settings repository has old state
return
}
LOG.runAndLogException {
val newElement = if (deleted) null else loadElement(useStreamProvider)
val states = storageDataRef.get()
if (newElement == null) {
// if data was loaded, mark as changed all loaded components
if (states != null) {
changedComponentNames.addAll(states.keys())
setStates(states, null)
}
}
else if (states != null) {
val newStates = loadState(newElement)
changedComponentNames.addAll(states.getChangedComponentNames(newStates))
setStates(states, newStates)
}
}
}
}
internal class XmlDataWriter(private val rootElementName: String?,
private val elements: List<Element>,
private val rootAttributes: Map<String, String>,
private val macroManager: PathMacroManager?) : StringDataWriter() {
override fun hasData(filter: DataWriterFilter): Boolean {
return elements.any { filter.hasData(it) }
}
override fun write(writer: Writer, lineSeparator: String, filter: DataWriterFilter?) {
var lineSeparatorWithIndent = lineSeparator
val hasRootElement = rootElementName != null
val replacePathMap = macroManager?.replacePathMap
val macroFilter = macroManager?.macroFilter
if (hasRootElement) {
lineSeparatorWithIndent += " "
writer.append('<').append(rootElementName)
for (entry in rootAttributes) {
writer.append(' ')
writer.append(entry.key)
writer.append('=')
writer.append('"')
var value = entry.value
if (replacePathMap != null) {
value = replacePathMap.substitute(JDOMUtil.escapeText(value, false, true), SystemInfoRt.isFileSystemCaseSensitive)
}
writer.append(JDOMUtil.escapeText(value, false, true))
writer.append('"')
}
if (elements.isEmpty()) {
// see note in save() why elements here can be an empty list
writer.append(" />")
return
}
writer.append('>')
}
val xmlOutputter = JbXmlOutputter(lineSeparatorWithIndent, filter?.toElementFilter(), replacePathMap, macroFilter)
for (element in elements) {
if (hasRootElement) {
writer.append(lineSeparatorWithIndent)
}
xmlOutputter.printElement(writer, element, 0)
}
if (rootElementName != null) {
writer.append(lineSeparator)
writer.append("</").append(rootElementName).append('>')
}
}
}
private fun save(states: StateMap, newLiveStates: Map<String, Element>? = null): MutableList<Element>? {
if (states.isEmpty()) {
return null
}
var result: MutableList<Element>? = null
for (componentName in states.keys()) {
val element: Element
try {
element = states.getElement(componentName, newLiveStates)?.clone() ?: continue
}
catch (e: Exception) {
LOG.error("Cannot save \"$componentName\" data", e)
continue
}
// name attribute should be first
val elementAttributes = element.attributes
var nameAttribute = element.getAttribute(FileStorageCoreUtil.NAME)
@Suppress("SuspiciousEqualsCombination")
if (nameAttribute != null && nameAttribute === elementAttributes.get(0) && componentName == nameAttribute.value) {
// all is OK
}
else {
if (nameAttribute == null) {
nameAttribute = Attribute(FileStorageCoreUtil.NAME, componentName)
elementAttributes.add(0, nameAttribute)
}
else {
nameAttribute.value = componentName
if (elementAttributes.get(0) != nameAttribute) {
elementAttributes.remove(nameAttribute)
elementAttributes.add(0, nameAttribute)
}
}
}
if (result == null) {
result = SmartList()
}
result.add(element)
}
return result
}
internal fun Element.normalizeRootName(): Element {
if (org.jdom.JDOMInterner.isInterned(this)) {
if (name == FileStorageCoreUtil.COMPONENT) {
return this
}
else {
val clone = clone()
clone.name = FileStorageCoreUtil.COMPONENT
return clone
}
}
else {
if (parent != null) {
LOG.warn("State element must not have parent: ${JDOMUtil.writeElement(this)}")
detach()
}
name = FileStorageCoreUtil.COMPONENT
return this
}
}
// newStorageData - myStates contains only live (unarchived) states
private fun StateMap.getChangedComponentNames(newStates: StateMap): Set<String> {
val bothStates = keys().toMutableSet()
bothStates.retainAll(newStates.keys())
val diffs = SmartHashSet<String>()
diffs.addAll(newStates.keys())
diffs.addAll(keys())
diffs.removeAll(bothStates)
for (componentName in bothStates) {
compare(componentName, newStates, diffs)
}
return diffs
}
enum class DataStateChanged {
LOADED, SAVED
}
interface DataWriterFilter {
enum class ElementLevel {
ZERO, FIRST
}
companion object {
fun requireAttribute(name: String, onLevel: ElementLevel): DataWriterFilter {
return object: DataWriterFilter {
override fun toElementFilter(): JDOMUtil.ElementOutputFilter {
return JDOMUtil.ElementOutputFilter { childElement, level -> level != onLevel.ordinal || childElement.getAttribute(name) != null }
}
override fun hasData(element: Element): Boolean {
val elementFilter = toElementFilter()
if (onLevel == ElementLevel.ZERO && elementFilter.accept(element, 0)) {
return true
}
return element.children.any { elementFilter.accept(it, 1) }
}
}
}
}
fun toElementFilter(): JDOMUtil.ElementOutputFilter
fun hasData(element: Element): Boolean
}
interface DataWriter {
// LineSeparator cannot be used because custom (with indent) line separator can be used
fun write(output: OutputStream, lineSeparator: String = LineSeparator.LF.separatorString, filter: DataWriterFilter? = null)
fun hasData(filter: DataWriterFilter): Boolean
}
internal fun DataWriter?.writeTo(file: Path, lineSeparator: String = LineSeparator.LF.separatorString) {
if (this == null) {
file.delete()
}
else {
file.safeOutputStream(null).use { write(it, lineSeparator) }
}
}
internal abstract class StringDataWriter : DataWriter {
final override fun write(output: OutputStream, lineSeparator: String, filter: DataWriterFilter?) {
output.bufferedWriter().use {
write(it, lineSeparator, filter)
}
}
internal abstract fun write(writer: Writer, lineSeparator: String, filter: DataWriterFilter?)
}
internal fun DataWriter.toBufferExposingByteArray(lineSeparator: LineSeparator = LineSeparator.LF): BufferExposingByteArrayOutputStream {
val out = BufferExposingByteArrayOutputStream(1024)
out.use { write(out, lineSeparator.separatorString) }
return out
}
// use ONLY for non-ordinal usages (default project, deprecated directoryBased storage)
internal fun createDataWriterForElement(element: Element): DataWriter {
return object: DataWriter {
override fun hasData(filter: DataWriterFilter) = filter.hasData(element)
override fun write(output: OutputStream, lineSeparator: String, filter: DataWriterFilter?) {
output.bufferedWriter().use { JbXmlOutputter(lineSeparator, filter?.toElementFilter(), null, null).output(element, it) }
}
}
} | platform/configuration-store-impl/src/XmlElementStorage.kt | 3015737185 |
// Copyright 2000-2018 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.
package com.intellij.internal
import com.intellij.ide.util.BrowseFilesListener
import com.intellij.openapi.actionSystem.AnActionEvent
import com.intellij.openapi.application.ApplicationInfo
import com.intellij.openapi.application.ApplicationNamesInfo
import com.intellij.openapi.fileChooser.FileChooserDescriptorFactory
import com.intellij.openapi.fileChooser.FileChooserFactory
import com.intellij.openapi.fileChooser.FileTextField
import com.intellij.openapi.project.DumbAwareAction
import com.intellij.openapi.project.Project
import com.intellij.openapi.ui.*
import com.intellij.openapi.updateSettings.impl.UpdateChecker
import com.intellij.ui.ScrollPaneFactory
import com.intellij.util.loadElement
import com.intellij.util.text.nullize
import com.intellij.util.ui.JBUI
import com.intellij.util.ui.UIUtil
import java.awt.BorderLayout
import java.awt.event.ActionEvent
import javax.swing.AbstractAction
import javax.swing.JComponent
import javax.swing.JPanel
import javax.swing.JTextArea
/**
* @author gregsh
*/
class ShowUpdateInfoDialogAction : DumbAwareAction() {
override fun actionPerformed(e: AnActionEvent) {
val dialog = MyDialog(e.project)
if (dialog.showAndGet()) {
try {
UpdateChecker.testPlatformUpdate(dialog.updateXmlText(), dialog.patchFilePath(), dialog.forceUpdate())
}
catch (ex: Exception) {
Messages.showErrorDialog(e.project, "${ex.javaClass.name}: ${ex.message}", "Something Went Wrong")
}
}
}
private class MyDialog(private val project: Project?) : DialogWrapper(project, true) {
private lateinit var textArea: JTextArea
private lateinit var fileField: FileTextField
private var forceUpdate = false
init {
title = "Updates.xml <channel> Text"
init()
}
override fun createCenterPanel(): JComponent? {
textArea = JTextArea(40, 100)
UIUtil.addUndoRedoActions(textArea)
textArea.wrapStyleWord = true
textArea.lineWrap = true
fileField = FileChooserFactory.getInstance().createFileTextField(BrowseFilesListener.SINGLE_FILE_DESCRIPTOR, disposable)
val fileCombo = TextFieldWithBrowseButton(fileField.field)
val fileDescriptor = FileChooserDescriptorFactory.createSingleLocalFileDescriptor()
fileCombo.addBrowseFolderListener("Patch File", "Patch file", project, fileDescriptor)
val panel = JPanel(BorderLayout(0, JBUI.scale(10)))
panel.add(ScrollPaneFactory.createScrollPane(textArea), BorderLayout.CENTER)
panel.add(LabeledComponent.create(fileCombo, "Patch file:"), BorderLayout.SOUTH)
return panel
}
override fun createActions() = arrayOf(
object : AbstractAction("&Check Updates") {
override fun actionPerformed(e: ActionEvent?) {
forceUpdate = false
doOKAction()
}
},
object : AbstractAction("&Show Dialog") {
override fun actionPerformed(e: ActionEvent?) {
forceUpdate = true
doOKAction()
}
},
cancelAction)
override fun doValidate(): ValidationInfo? {
val text = textArea.text?.trim() ?: ""
if (text.isEmpty()) {
return ValidationInfo("Please paste something here", textArea)
}
try { loadElement(completeUpdateInfoXml(text)) }
catch (e: Exception) {
return ValidationInfo(e.message ?: "Error: ${e.javaClass.name}", textArea)
}
return super.doValidate()
}
override fun getPreferredFocusedComponent() = textArea
override fun getDimensionServiceKey() = "TEST_UPDATE_INFO_DIALOG"
internal fun updateXmlText() = completeUpdateInfoXml(textArea.text?.trim() ?: "")
internal fun forceUpdate() = forceUpdate
internal fun patchFilePath() = fileField.field.text.nullize(nullizeSpaces = true)
private fun completeUpdateInfoXml(text: String) =
when (loadElement(text).name) {
"products" -> text
"channel" -> {
val productName = ApplicationNamesInfo.getInstance().fullProductName
val productCode = ApplicationInfo.getInstance().build.productCode
"""<products><product name="${productName}"><code>${productCode}</code>${text}</product></products>"""
}
else -> throw IllegalArgumentException("Unknown root element")
}
}
} | platform/platform-impl/src/com/intellij/internal/ShowUpdateInfoDialogAction.kt | 2854773700 |
// PSI_ELEMENT: org.jetbrains.kotlin.psi.KtParameter
// OPTIONS: usages
data class A(val <caret>n: Int, val s: String, val o: Any)
fun test() {
for ((x, y, z) in arrayOf<A>()) {
}
for (a in listOf<A>()) {
val (x, y) = a
}
}
// FIR_IGNORE
// FIR_COMPARISON_WITH_DISABLED_COMPONENTS | plugins/kotlin/idea/tests/testData/findUsages/kotlin/conventions/components/for.0.kt | 6392625 |
// 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.inspections
import org.jetbrains.kotlin.idea.intentions.SpecifyTypeExplicitlyIntention
import org.jetbrains.kotlin.psi.KtCallableDeclaration
abstract class AbstractImplicitTypeInspection(
additionalChecker: (KtCallableDeclaration, AbstractImplicitTypeInspection) -> Boolean
) : IntentionBasedInspection<KtCallableDeclaration>(
SpecifyTypeExplicitlyIntention::class,
{ element, inspection ->
with(inspection as AbstractImplicitTypeInspection) {
element.typeReference == null && additionalChecker(element, inspection)
}
}
) {
override fun inspectionTarget(element: KtCallableDeclaration) = element.nameIdentifier
} | plugins/kotlin/idea/src/org/jetbrains/kotlin/idea/inspections/AbstractImplicitTypeInspection.kt | 1815747182 |
package com.tinmegali.myweather.data
import android.arch.persistence.room.Database
import android.arch.persistence.room.RoomDatabase
import com.tinmegali.myweather.models.WeatherMain
@Database( entities = arrayOf(WeatherMain::class), version = 2 )
abstract class Database : RoomDatabase() {
abstract fun weatherDAO(): WeatherDAO
} | app/src/main/java/com/tinmegali/myweather/data/Database.kt | 2587478213 |
/*
* Kores - Java source and Bytecode generation framework <https://github.com/JonathanxD/Kores>
*
* The MIT License (MIT)
*
* Copyright (c) 2020 TheRealBuggy/JonathanxD (https://github.com/JonathanxD/) <[email protected]>
* Copyright (c) contributors
*
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package com.github.jonathanxd.kores.base
import com.github.jonathanxd.kores.KoresPart
/**
* Same as [ElementsHolder] but holds constructors.
*/
interface ConstructorsHolder : KoresPart {
/**
* Constructor declarations
*/
val constructors: List<ConstructorDeclaration>
override fun builder(): Builder<ConstructorsHolder, *>
interface Builder<out T : ConstructorsHolder, S : Builder<T, S>> :
com.github.jonathanxd.kores.builder.Builder<T, S> {
/**
* See [ConstructorsHolder.constructors]
*/
fun constructors(value: List<ConstructorDeclaration>): S
/**
* See [ConstructorsHolder.constructors]
*/
fun constructors(vararg values: ConstructorDeclaration): S =
this.constructors(values.toList())
/**
* See [ConstructorsHolder.constructors]
*/
fun constructors(value: ConstructorDeclaration): S = this.constructors(listOf(value))
}
} | src/main/kotlin/com/github/jonathanxd/kores/base/ConstructorsHolder.kt | 1003422706 |
// 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 com.intellij.model.psi.impl
import com.intellij.openapi.diagnostic.Logger
import com.intellij.openapi.editor.Editor
import com.intellij.openapi.editor.impl.ImaginaryEditor
import com.intellij.psi.PsiDocumentManager
import com.intellij.psi.PsiFile
internal val LOG: Logger = Logger.getInstance("#com.intellij.model.psi.impl")
internal fun mockEditor(file: PsiFile): Editor? {
val project = file.project
val document = PsiDocumentManager.getInstance(project).getDocument(file) ?: return null
return object : ImaginaryEditor(project, document) {
override fun toString(): String = "API compatibility editor"
}
}
| platform/lang-impl/src/com/intellij/model/psi/impl/util.kt | 3876812168 |
package com.mikepenz.fastadapter.utils
import com.mikepenz.fastadapter.GenericItem
/**
* Created by mikepenz on 30.12.15.
*/
interface InterceptorUtil {
companion object {
@JvmField
val DEFAULT: (element: GenericItem) -> GenericItem? = { it }
}
}
| fastadapter/src/main/java/com/mikepenz/fastadapter/utils/InterceptorUtil.kt | 2931091343 |
package me.serce.solidity.lang.stubs
import com.intellij.psi.PsiFile
import com.intellij.psi.StubBuilder
import com.intellij.psi.stubs.*
import com.intellij.psi.tree.IStubFileElementType
import me.serce.solidity.lang.SolidityLanguage
import me.serce.solidity.lang.core.SolidityFile
import me.serce.solidity.lang.psi.*
import me.serce.solidity.lang.psi.impl.*
class SolidityFileStub(file: SolidityFile?) : PsiFileStubImpl<SolidityFile>(file) {
override fun getType() = Type
object Type : IStubFileElementType<SolidityFileStub>(SolidityLanguage) {
// bump version every time stub tree changes
override fun getStubVersion() = 15
override fun getBuilder(): StubBuilder = object : DefaultStubBuilder() {
override fun createStubForFile(file: PsiFile) = SolidityFileStub(file as SolidityFile)
}
override fun serialize(stub: SolidityFileStub, dataStream: StubOutputStream) {}
override fun deserialize(dataStream: StubInputStream, parentStub: StubElement<*>?) = SolidityFileStub(null)
override fun getExternalId(): String = "Solidity.file"
}
}
fun factory(name: String): SolStubElementType<*, *> = when (name) {
"ENUM_DEFINITION" -> SolEnumDefStub.Type
"CONTRACT_DEFINITION" -> SolContractOrLibDefStub.Type
"FUNCTION_DEFINITION" -> SolFunctionDefStub.Type
"MODIFIER_DEFINITION" -> SolModifierDefStub.Type
"STRUCT_DEFINITION" -> SolStructDefStub.Type
"EVENT_DEFINITION" -> SolEventDefStub.Type
"ERROR_DEFINITION" -> SolErrorDefStub.Type
"USER_DEFINED_VALUE_TYPE_DEFINITION" -> SolUserDefinedValueTypeDefStub.Type
"STATE_VARIABLE_DECLARATION" -> SolStateVarDeclStub.Type
"CONSTANT_VARIABLE_DECLARATION" -> SolConstantVariableDeclStub.Type
"IMPORT_PATH" -> SolImportPathDefStub.Type
"ELEMENTARY_TYPE_NAME" -> SolTypeRefStub.Type("ELEMENTARY_TYPE_NAME", ::SolElementaryTypeNameImpl)
"MAPPING_TYPE_NAME" -> SolTypeRefStub.Type("MAPPING_TYPE_NAME", ::SolMappingTypeNameImpl)
"FUNCTION_TYPE_NAME" -> SolTypeRefStub.Type("FUNCTION_TYPE_NAME", ::SolFunctionTypeNameImpl)
"ARRAY_TYPE_NAME" -> SolTypeRefStub.Type("ARRAY_TYPE_NAME", ::SolArrayTypeNameImpl)
"BYTES_ARRAY_TYPE_NAME" -> SolTypeRefStub.Type("BYTES_ARRAY_TYPE_NAME", ::SolBytesArrayTypeNameImpl)
"USER_DEFINED_LOCATION_TYPE_NAME" -> SolTypeRefStub.Type("USER_DEFINED_LOCATION_TYPE_NAME", ::SolUserDefinedLocationTypeNameImpl)
"USER_DEFINED_TYPE_NAME" -> SolTypeRefStub.Type("USER_DEFINED_TYPE_NAME", ::SolUserDefinedTypeNameImpl)
else -> error("Unknown element $name")
}
class SolEnumDefStub(
parent: StubElement<*>?,
elementType: IStubElementType<*, *>,
override val name: String?
) : StubBase<SolEnumDefinition>(parent, elementType), SolNamedStub {
object Type : SolStubElementType<SolEnumDefStub, SolEnumDefinition>("ENUM_DEFINITION") {
override fun deserialize(dataStream: StubInputStream, parentStub: StubElement<*>?) =
SolEnumDefStub(parentStub, this, dataStream.readNameAsString())
override fun serialize(stub: SolEnumDefStub, dataStream: StubOutputStream) = with(dataStream) {
writeName(stub.name)
}
override fun createPsi(stub: SolEnumDefStub) = SolEnumDefinitionImpl(stub, this)
override fun createStub(psi: SolEnumDefinition, parentStub: StubElement<*>?) =
SolEnumDefStub(parentStub, this, psi.name)
override fun indexStub(stub: SolEnumDefStub, sink: IndexSink) = sink.indexEnumDef(stub)
}
}
class SolUserDefinedValueTypeDefStub(
parent: StubElement<*>?,
elementType: IStubElementType<*, *>,
override val name: String?
) : StubBase<SolUserDefinedValueTypeDefinition>(parent, elementType), SolNamedStub {
object Type : SolStubElementType<SolUserDefinedValueTypeDefStub, SolUserDefinedValueTypeDefinition>("USER_DEFINED_VALUE_TYPE_DEFINITION") {
override fun deserialize(dataStream: StubInputStream, parentStub: StubElement<*>?) =
SolUserDefinedValueTypeDefStub(parentStub, this, dataStream.readNameAsString())
override fun serialize(stub: SolUserDefinedValueTypeDefStub, dataStream: StubOutputStream) = with(dataStream) {
writeName(stub.name)
}
override fun createPsi(stub: SolUserDefinedValueTypeDefStub) = SolUserDefinedValueTypeDefinitionImpl(stub, this)
override fun createStub(psi: SolUserDefinedValueTypeDefinition, parentStub: StubElement<*>?) =
SolUserDefinedValueTypeDefStub(parentStub, this, psi.name)
override fun indexStub(stub: SolUserDefinedValueTypeDefStub, sink: IndexSink) = sink.indexUserDefinedValueTypeDef(stub)
}
}
class SolFunctionDefStub(
parent: StubElement<*>?,
elementType: IStubElementType<*, *>,
override val name: String?
) : StubBase<SolFunctionDefinition>(parent, elementType), SolNamedStub {
object Type : SolStubElementType<SolFunctionDefStub, SolFunctionDefinition>("FUNCTION_DEFINITION") {
override fun deserialize(dataStream: StubInputStream, parentStub: StubElement<*>?) =
SolFunctionDefStub(parentStub, this, dataStream.readNameAsString())
override fun serialize(stub: SolFunctionDefStub, dataStream: StubOutputStream) = with(dataStream) {
writeName(stub.name)
}
override fun createPsi(stub: SolFunctionDefStub) = SolFunctionDefinitionImpl(stub, this)
override fun createStub(psi: SolFunctionDefinition, parentStub: StubElement<*>?) =
SolFunctionDefStub(parentStub, this, psi.name)
override fun indexStub(stub: SolFunctionDefStub, sink: IndexSink) = sink.indexFunctionDef(stub)
}
}
class SolModifierDefStub(
parent: StubElement<*>?,
elementType: IStubElementType<*, *>,
override val name: String?
) : StubBase<SolModifierDefinition>(parent, elementType), SolNamedStub {
object Type : SolStubElementType<SolModifierDefStub, SolModifierDefinition>("MODIFIER_DEFINITION") {
override fun deserialize(dataStream: StubInputStream, parentStub: StubElement<*>?) =
SolModifierDefStub(parentStub, this, dataStream.readNameAsString())
override fun serialize(stub: SolModifierDefStub, dataStream: StubOutputStream) = with(dataStream) {
writeName(stub.name)
}
override fun createPsi(stub: SolModifierDefStub) = SolModifierDefinitionImpl(stub, this)
override fun createStub(psi: SolModifierDefinition, parentStub: StubElement<*>?) =
SolModifierDefStub(parentStub, this, psi.name)
override fun indexStub(stub: SolModifierDefStub, sink: IndexSink) = sink.indexModifierDef(stub)
}
}
class SolStructDefStub(
parent: StubElement<*>?,
elementType: IStubElementType<*, *>,
override val name: String?
) : StubBase<SolStructDefinition>(parent, elementType), SolNamedStub {
object Type : SolStubElementType<SolStructDefStub, SolStructDefinition>("STRUCT_DEFINITION") {
override fun deserialize(dataStream: StubInputStream, parentStub: StubElement<*>?) =
SolStructDefStub(parentStub, this, dataStream.readNameAsString())
override fun serialize(stub: SolStructDefStub, dataStream: StubOutputStream) = with(dataStream) {
writeName(stub.name)
}
override fun createPsi(stub: SolStructDefStub) = SolStructDefinitionImpl(stub, this)
override fun createStub(psi: SolStructDefinition, parentStub: StubElement<*>?) =
SolStructDefStub(parentStub, this, psi.name)
override fun indexStub(stub: SolStructDefStub, sink: IndexSink) = sink.indexStructDef(stub)
}
}
class SolStateVarDeclStub(
parent: StubElement<*>?,
elementType: IStubElementType<*, *>,
override val name: String?
) : StubBase<SolStateVariableDeclaration>(parent, elementType), SolNamedStub {
object Type : SolStubElementType<SolStateVarDeclStub, SolStateVariableDeclaration>("STATE_VARIABLE_DECLARATION") {
override fun deserialize(dataStream: StubInputStream, parentStub: StubElement<*>?) =
SolStateVarDeclStub(parentStub, this, dataStream.readNameAsString())
override fun serialize(stub: SolStateVarDeclStub, dataStream: StubOutputStream) = with(dataStream) {
writeName(stub.name)
}
override fun createPsi(stub: SolStateVarDeclStub) = SolStateVariableDeclarationImpl(stub, this)
override fun createStub(psi: SolStateVariableDeclaration, parentStub: StubElement<*>?) =
SolStateVarDeclStub(parentStub, this, psi.name)
override fun indexStub(stub: SolStateVarDeclStub, sink: IndexSink) = sink.indexStateVarDecl(stub)
}
}
class SolConstantVariableDeclStub(
parent: StubElement<*>?,
elementType: IStubElementType<*, *>,
override val name: String?
) : StubBase<SolConstantVariableDeclaration>(parent, elementType), SolNamedStub {
object Type : SolStubElementType<SolConstantVariableDeclStub, SolConstantVariableDeclaration>("CONSTANT_VARIABLE_DECLARATION") {
override fun deserialize(dataStream: StubInputStream, parentStub: StubElement<*>?) =
SolConstantVariableDeclStub(parentStub, this, dataStream.readNameAsString())
override fun serialize(stub: SolConstantVariableDeclStub, dataStream: StubOutputStream) = with(dataStream) {
writeName(stub.name)
}
override fun createPsi(stub: SolConstantVariableDeclStub) = SolConstantVariableDeclarationImpl(stub, this)
override fun createStub(psi: SolConstantVariableDeclaration, parentStub: StubElement<*>?) =
SolConstantVariableDeclStub(parentStub, this, psi.name)
override fun indexStub(stub: SolConstantVariableDeclStub, sink: IndexSink) = sink.indexConstantVariableDecl(stub)
}
}
class SolContractOrLibDefStub(
parent: StubElement<*>?,
elementType: IStubElementType<*, *>,
override val name: String?
) : StubBase<SolContractDefinition>(parent, elementType), SolNamedStub {
object Type : SolStubElementType<SolContractOrLibDefStub, SolContractDefinition>("CONTRACT_DEFINITION") {
override fun deserialize(dataStream: StubInputStream, parentStub: StubElement<*>?) =
SolContractOrLibDefStub(parentStub, this, dataStream.readNameAsString())
override fun serialize(stub: SolContractOrLibDefStub, dataStream: StubOutputStream) = with(dataStream) {
writeName(stub.name)
}
override fun createPsi(stub: SolContractOrLibDefStub) = SolContractDefinitionImpl(stub, this)
override fun createStub(psi: SolContractDefinition, parentStub: StubElement<*>?) =
SolContractOrLibDefStub(parentStub, this, psi.name)
override fun indexStub(stub: SolContractOrLibDefStub, sink: IndexSink) = sink.indexContractDef(stub)
}
}
class SolTypeRefStub(
parent: StubElement<*>?,
elementType: IStubElementType<*, *>
) : StubBase<SolTypeName>(parent, elementType) {
class Type<T : SolTypeName>(
debugName: String,
private val psiFactory: (SolTypeRefStub, IStubElementType<*, *>) -> T
) : SolStubElementType<SolTypeRefStub, T>(debugName) {
override fun deserialize(dataStream: StubInputStream, parentStub: StubElement<*>?) =
SolTypeRefStub(parentStub, this)
override fun serialize(stub: SolTypeRefStub, dataStream: StubOutputStream) = with(dataStream) {
}
override fun createPsi(stub: SolTypeRefStub) = psiFactory(stub, this)
override fun createStub(psi: T, parentStub: StubElement<*>?) = SolTypeRefStub(parentStub, this)
override fun indexStub(stub: SolTypeRefStub, sink: IndexSink) {}
}
}
class SolEventDefStub(
parent: StubElement<*>?,
elementType: IStubElementType<*, *>,
override val name: String?
) : StubBase<SolEventDefinition>(parent, elementType), SolNamedStub {
object Type : SolStubElementType<SolEventDefStub, SolEventDefinition>("EVENT_DEFINITION") {
override fun deserialize(dataStream: StubInputStream, parentStub: StubElement<*>?) =
SolEventDefStub(parentStub, this, dataStream.readNameAsString())
override fun serialize(stub: SolEventDefStub, dataStream: StubOutputStream) = with(dataStream) {
writeName(stub.name)
}
override fun createPsi(stub: SolEventDefStub) = SolEventDefinitionImpl(stub, this)
override fun createStub(psi: SolEventDefinition, parentStub: StubElement<*>?) =
SolEventDefStub(parentStub, this, psi.name)
override fun indexStub(stub: SolEventDefStub, sink: IndexSink) = sink.indexEventDef(stub)
}
}
class SolErrorDefStub(
parent: StubElement<*>?,
elementType: IStubElementType<*, *>,
override val name: String?
) : StubBase<SolErrorDefinition>(parent, elementType), SolNamedStub {
object Type : SolStubElementType<SolErrorDefStub, SolErrorDefinition>("ERROR_DEFINITION") {
override fun deserialize(dataStream: StubInputStream, parentStub: StubElement<*>?) =
SolErrorDefStub(parentStub, this, dataStream.readNameAsString())
override fun serialize(stub: SolErrorDefStub, dataStream: StubOutputStream) = with(dataStream) {
writeName(stub.name)
}
override fun createPsi(stub: SolErrorDefStub) = SolErrorDefinitionImpl(stub, this)
override fun createStub(psi: SolErrorDefinition, parentStub: StubElement<*>?) =
SolErrorDefStub(parentStub, this, psi.name)
override fun indexStub(stub: SolErrorDefStub, sink: IndexSink) = sink.indexErrorDef(stub)
}
}
class SolImportPathDefStub(
parent: StubElement<*>?,
elementType: IStubElementType<*, *>,
override val name: String?,
val path: String?
) : StubBase<SolImportPathImpl>(parent, elementType), SolNamedStub {
object Type : SolStubElementType<SolImportPathDefStub, SolImportPathImpl>("IMPORT_PATH") {
override fun deserialize(dataStream: StubInputStream, parentStub: StubElement<*>?) =
SolImportPathDefStub(parentStub, this, dataStream.readNameAsString(), dataStream.readUTFFast())
override fun serialize(stub: SolImportPathDefStub, dataStream: StubOutputStream) = with(dataStream) {
writeName(stub.name)
writeUTFFast(stub.path ?: "")
}
override fun createPsi(stub: SolImportPathDefStub) = SolImportPathImpl(stub, this)
override fun createStub(psi: SolImportPathImpl, parentStub: StubElement<*>?) = SolImportPathDefStub(parentStub, this, psi.name, psi.text)
override fun indexStub(stub: SolImportPathDefStub, sink: IndexSink) = sink.indexImportPathDef(stub)
}
}
private fun StubInputStream.readNameAsString(): String? = readName()?.string
| src/main/kotlin/me/serce/solidity/lang/stubs/impl.kt | 527515023 |
// !DIAGNOSTICS_NUMBER: 2
// !DIAGNOSTICS: TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS
// !LANGUAGE: -NewInference
// see DiagnosticMessageTest
import java.io.Closeable
class MyList<T>(t: T) {}
fun <T> getMyList(t: T): MyList<T> = MyList(t)
fun <T, E: Cloneable> writeToMyList (l: MyList< in T>, t: T) where E: Closeable {}
class Cons<T, E: Cloneable>(l: MyList<in T>, t: T)
fun test1(int: Int, any: Any) {
writeToMyList(getMyList(int), any)
Cons(getMyList(int), any)
}
| plugins/kotlin/idea/tests/testData/diagnosticMessage/conflictingSubstitutions.kt | 2440199127 |
// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
package org.jetbrains.intellij.build.testFramework.binaryReproducibility
import org.jetbrains.intellij.build.BuildContext
import org.jetbrains.intellij.build.BuildOptions
import org.jetbrains.intellij.build.JvmArchitecture
import org.jetbrains.intellij.build.OsFamily
import org.jetbrains.intellij.build.impl.getOsDistributionBuilder
import java.nio.file.Path
import java.util.*
import kotlin.io.path.exists
import kotlin.io.path.isDirectory
import kotlin.io.path.isRegularFile
class BuildArtifactsReproducibilityTest {
private val buildDateInSeconds = System.getenv("SOURCE_DATE_EPOCH")?.toLongOrNull()
private val randomSeedNumber = Random().nextLong()
private lateinit var diffDirectory: Path
val isEnabled = System.getProperty("intellij.build.test.artifacts.reproducibility") == "true"
fun configure(options: BuildOptions) {
assert(isEnabled)
requireNotNull(buildDateInSeconds) {
"SOURCE_DATE_EPOCH environment variable is required"
}
options.buildDateInSeconds = buildDateInSeconds
options.randomSeedNumber = randomSeedNumber
// FIXME IJI-823 workaround
options.buildStepsToSkip.add(BuildOptions.PREBUILD_SHARED_INDEXES)
options.buildStepsToSkip.remove(BuildOptions.OS_SPECIFIC_DISTRIBUTIONS_STEP)
}
fun compare(context1: BuildContext, context2: BuildContext) {
assert(isEnabled)
assert(!this::diffDirectory.isInitialized)
diffDirectory = System.getProperty("intellij.build.test.artifacts.reproducibility.diffDir")?.let { Path.of(it) }
?: context1.paths.artifactDir.resolve(".diff")
val errors = OsFamily.ALL.asSequence().flatMap { os ->
val artifacts1 = getOsDistributionBuilder(os, context = context1)!!.getArtifactNames(context1)
val artifacts2 = getOsDistributionBuilder(os, context = context2)!!.getArtifactNames(context2)
assert(artifacts1 == artifacts2)
artifacts1.map { "artifacts/$it" } + "dist.${os.distSuffix}" + JvmArchitecture.ALL.map { "dist.${os.distSuffix}.$it" }
}.plus("dist.all").plus("dist").mapNotNull {
val path1 = context1.paths.buildOutputDir.resolve(it)
val path2 = context2.paths.buildOutputDir.resolve(it)
if (!path1.exists() && !path2.exists()) {
context1.messages.warning("Neither $path1 nor $path2 exists")
return@mapNotNull null
}
val diff = diffDirectory.resolve(it)
val test = FileTreeContentTest(diff, context1.paths.tempDir)
val error = when {
path1.isDirectory() && path2.isDirectory() -> test.assertTheSameContent(path1, path2)
path1.isRegularFile() && path2.isRegularFile() -> test.assertTheSame(Path.of(it),
context1.paths.buildOutputDir,
context2.paths.buildOutputDir)
else -> error("Unable to compare $path1 and $path2")
}
if (error != null) {
context1.messages.artifactBuilt("$diff")
}
else {
context1.messages.info("$path1 and $path2 are byte-to-byte identical.")
}
error
}.toList()
if (errors.isNotEmpty()) {
throw Exception("Build is not reproducible").apply {
errors.forEach(::addSuppressed)
}
}
}
} | platform/build-scripts/testFramework/src/org/jetbrains/intellij/build/testFramework/binaryReproducibility/BuildArtifactsReproducibilityTest.kt | 3909600736 |
// WITH_STDLIB
fun fn(index : Int, list: List<()->Unit>) {
when {
index in list.indices -> <selection>list[index]</selection>()
}
} | plugins/kotlin/idea/tests/testData/refactoring/introduceVariable/ComplexCallee.kt | 3548669795 |
package org.jetbrains.spek.junit
import org.jetbrains.spek.api.*
import org.junit.runner.Description
import org.junit.runner.notification.Failure
import org.junit.runner.notification.RunNotifier
import org.junit.runners.ParentRunner
import java.io.Serializable
import kotlin.collections.arrayListOf
import kotlin.collections.getOrPut
import kotlin.collections.hashMapOf
data class JUnitUniqueId(val id: Int) : Serializable {
companion object {
var id = 0
fun next() = JUnitUniqueId(id++)
}
}
fun junitAction(description: Description, notifier: RunNotifier, action: () -> Unit) {
if (description.isTest) notifier.fireTestStarted(description)
try {
action()
} catch(e: SkippedException) {
notifier.fireTestIgnored(description)
} catch(e: PendingException) {
notifier.fireTestIgnored(description)
} catch(e: Throwable) {
notifier.fireTestFailure(Failure(description, e))
} finally {
if (description.isTest) notifier.fireTestFinished(description)
}
}
class JUnitOnRunner<T>(val specificationClass: Class<T>, val given: TestGivenAction, val on: TestOnAction) : ParentRunner<TestItAction>(specificationClass) {
val _children by lazy(LazyThreadSafetyMode.NONE) {
val result = arrayListOf<TestItAction>()
try {
on.iterateIt { result.add(it) }
} catch (e: SkippedException) {
} catch (e: PendingException) {
}
result
}
val _description by lazy(LazyThreadSafetyMode.NONE) {
val desc = Description.createSuiteDescription(on.description(), JUnitUniqueId.next())!!
for (item in children) {
desc.addChild(describeChild(item))
}
desc
}
val childrenDescriptions = hashMapOf<String, Description>()
override fun getChildren(): MutableList<TestItAction> = _children
override fun getDescription(): Description? = _description
protected override fun describeChild(child: TestItAction?): Description? {
return childrenDescriptions.getOrPut(child!!.description(), {
Description.createSuiteDescription("${child.description()} (${on.description()})", JUnitUniqueId.next())!!
})
}
protected override fun runChild(child: TestItAction?, notifier: RunNotifier?) {
junitAction(describeChild(child)!!, notifier!!) {
child!!.run()
}
}
}
class JUnitGivenRunner<T>(val specificationClass: Class<T>, val given: TestGivenAction) : ParentRunner<JUnitOnRunner<T>>(specificationClass) {
val _children by lazy(LazyThreadSafetyMode.NONE) {
val result = arrayListOf<JUnitOnRunner<T>>()
try {
given.iterateOn { result.add(JUnitOnRunner(specificationClass, given, it)) }
} catch (e: SkippedException) {
} catch (e: PendingException) {
}
result
}
val _description by lazy(LazyThreadSafetyMode.NONE) {
val desc = Description.createSuiteDescription(given.description(), JUnitUniqueId.next())!!
for (item in children) {
desc.addChild(describeChild(item))
}
desc
}
override fun getChildren(): MutableList<JUnitOnRunner<T>> = _children
override fun getDescription(): Description? = _description
protected override fun describeChild(child: JUnitOnRunner<T>?): Description? {
return child?.description
}
protected override fun runChild(child: JUnitOnRunner<T>?, notifier: RunNotifier?) {
junitAction(describeChild(child)!!, notifier!!) {
child!!.run(notifier)
}
}
}
class JUnitClassRunner<T>(val specificationClass: Class<T>) : ParentRunner<JUnitGivenRunner<T>>(specificationClass) {
private val suiteDescription = Description.createSuiteDescription(specificationClass)
override fun getChildren(): MutableList<JUnitGivenRunner<T>> = _children
val _children by lazy(LazyThreadSafetyMode.NONE) {
if (Spek::class.java.isAssignableFrom(specificationClass) && !specificationClass.isLocalClass) {
val spek = specificationClass.newInstance() as Spek
val result = arrayListOf<JUnitGivenRunner<T>>()
spek.iterateGiven { result.add(JUnitGivenRunner(specificationClass, it)) }
result
} else
arrayListOf()
}
protected override fun describeChild(child: JUnitGivenRunner<T>?): Description? {
return child?.description
}
protected override fun runChild(child: JUnitGivenRunner<T>?, notifier: RunNotifier?) {
junitAction(describeChild(child)!!, notifier!!) {
child!!.run(notifier)
}
}
}
| spek-core/src/main/kotlin/org/jetbrains/spek/junit/JUnitClassRunner.kt | 2314794001 |
// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
package org.jetbrains.kotlin.idea.inspections
import com.intellij.codeInspection.CleanupLocalInspectionTool
import com.intellij.codeInspection.IntentionWrapper
import com.intellij.codeInspection.ProblemHighlightType
import com.intellij.codeInspection.ProblemsHolder
import com.intellij.psi.PsiElementVisitor
import org.jetbrains.kotlin.descriptors.ClassDescriptor
import org.jetbrains.kotlin.idea.KotlinBundle
import org.jetbrains.kotlin.idea.caches.resolve.analyze
import org.jetbrains.kotlin.idea.intentions.AddNamesToCallArgumentsIntention
import org.jetbrains.kotlin.psi.KtNameReferenceExpression
import org.jetbrains.kotlin.psi.callExpressionVisitor
import org.jetbrains.kotlin.psi.psiUtil.referenceExpression
import org.jetbrains.kotlin.resolve.BindingContext
import org.jetbrains.kotlin.resolve.DataClassDescriptorResolver
import org.jetbrains.kotlin.resolve.calls.util.getResolvedCall
import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
class CopyWithoutNamedArgumentsInspection : AbstractKotlinInspection(), CleanupLocalInspectionTool {
override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
return callExpressionVisitor(fun(expression) {
val reference = expression.referenceExpression() as? KtNameReferenceExpression ?: return
if (reference.getReferencedNameAsName() != DataClassDescriptorResolver.COPY_METHOD_NAME) return
if (expression.valueArguments.all { it.isNamed() }) return
val context = expression.analyze(BodyResolveMode.PARTIAL)
val call = expression.getResolvedCall(context) ?: return
val receiver = call.dispatchReceiver?.type?.constructor?.declarationDescriptor as? ClassDescriptor ?: return
if (!receiver.isData) return
if (call.candidateDescriptor != context[BindingContext.DATA_CLASS_COPY_FUNCTION, receiver]) return
holder.registerProblem(
expression.calleeExpression ?: return,
KotlinBundle.message("copy.method.of.data.class.is.called.without.named.arguments"),
ProblemHighlightType.GENERIC_ERROR_OR_WARNING,
IntentionWrapper(AddNamesToCallArgumentsIntention())
)
})
}
} | plugins/kotlin/idea/src/org/jetbrains/kotlin/idea/inspections/CopyWithoutNamedArgumentsInspection.kt | 2321231276 |
package com.homemods.relay.pi.bluetooth
import com.homemods.relay.bluetooth.BluetoothConnection
import com.homemods.relay.bluetooth.BluetoothServer
import javax.bluetooth.DiscoveryAgent
import javax.bluetooth.LocalDevice
import javax.bluetooth.UUID
import javax.microedition.io.Connector
import javax.microedition.io.StreamConnectionNotifier
/**
* @author sergeys
*/
class PiBluetoothServer : BluetoothServer {
private var running: Boolean = true
private var discoveryThread: Thread? = null
override fun beginDiscovery(onDiscovery: (BluetoothConnection) -> Unit) {
if (discoveryThread != null) throw Exception("Server already in discovery mode")
running = false
discoveryThread = Thread(
{
val localDevice = LocalDevice.getLocalDevice()!!
localDevice.discoverable = DiscoveryAgent.GIAC
val uuid = UUID("9fb18ac2a4fd865a79163c954fa189bf", false)
println(uuid)
val url = "btspp://localhost:$uuid;name=RemoteBluetooth"
val streamConnectionNotifier = Connector.open(url) as StreamConnectionNotifier
while (running) {
val connection = streamConnectionNotifier.acceptAndOpen()!!
onDiscovery(PiBluetoothConnection(connection))
}
streamConnectionNotifier.close()
}, "Bluetooth Discovery Thread").apply {
isDaemon = true
start()
}
}
override fun endDiscovery() {
if (discoveryThread == null) throw Exception("Server not in discovery mode")
running = false
discoveryThread?.apply {
@Suppress("DEPRECATION")
stop()
}
}
}
| pi/src/com/homemods/relay/pi/bluetooth/PiBluetoothServer.kt | 3652937379 |
/*
* Copyright (C) 2018 Florian Dreier
*
* This file is part of MyTargets.
*
* MyTargets is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2
* as published by the Free Software Foundation.
*
* MyTargets is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
package de.dreier.mytargets.base.db.migrations
import androidx.sqlite.db.SupportSQLiteDatabase
import androidx.room.migration.Migration
object Migration13 : Migration(12, 13) {
override fun migrate(database: SupportSQLiteDatabase) {
database.execSQL(
"UPDATE PASSE SET exact=1 " +
"WHERE _id IN (SELECT DISTINCT p._id " +
"FROM PASSE p, SHOOT s " +
"WHERE p._id=s.passe " +
"AND s.x!=0)"
)
database.execSQL("ALTER TABLE TRAINING ADD COLUMN exact INTEGER DEFAULT 0")
database.execSQL(
"UPDATE TRAINING SET exact=1 " +
"WHERE _id IN (SELECT DISTINCT t._id " +
"FROM TRAINING t, ROUND r, PASSE p " +
"WHERE t._id=r.training " +
"AND r._id=p.round " +
"AND p.exact=1)"
)
}
}
| app/src/main/java/de/dreier/mytargets/base/db/migrations/Migration13.kt | 1621006573 |
package org.secfirst.umbrella.feature.maskapp
import android.app.Application
import dagger.BindsInstance
import dagger.Component
import dagger.Module
import dagger.Provides
import dagger.android.AndroidInjectionModule
import org.secfirst.umbrella.di.module.AppModule
import org.secfirst.umbrella.di.module.NetworkModule
import org.secfirst.umbrella.di.module.RepositoryModule
import org.secfirst.umbrella.feature.maskapp.interactor.MaskAppBaseInteractor
import org.secfirst.umbrella.feature.maskapp.interactor.MaskAppInteractorImp
import org.secfirst.umbrella.feature.maskapp.presenter.MaskAppBasePresenter
import org.secfirst.umbrella.feature.maskapp.presenter.MaskAppPresenterImp
import org.secfirst.umbrella.feature.maskapp.view.CalculatorController
import org.secfirst.umbrella.feature.maskapp.view.MaskAppView
import javax.inject.Singleton
@Module
class MaskAppModule {
@Provides
internal fun provideMaskAppInteractor(interactor: MaskAppInteractorImp): MaskAppBaseInteractor = interactor
@Provides
internal fun provideMaskAppPresenter(presenter: MaskAppPresenterImp<MaskAppView, MaskAppBaseInteractor>)
: MaskAppBasePresenter<MaskAppView, MaskAppBaseInteractor> = presenter
}
@Singleton
@Component(modules = [MaskAppModule::class,
RepositoryModule::class,
AppModule::class,
NetworkModule::class,
AndroidInjectionModule::class])
interface MaskAppComponent {
@Component.Builder
interface Builder {
@BindsInstance
fun application(application: Application): Builder
fun build(): MaskAppComponent
}
fun inject(calculatorController: CalculatorController)
} | app/src/main/java/org/secfirst/umbrella/feature/maskapp/MaskAppModule.kt | 2980279975 |
fun getString() = "Hello world"
object Test {
@JvmOverloads @JvmStatic
fun testStaticFunction(a: Int, b: String = getString(), c: Double, d: Float = 1.0f, e: Boolean): Int = a
@JvmOverloads
fun testMemberFunction(a: Int, b: String = getString(), c: Double, d: Float = 1.0f, e: Boolean): Int = a
@JvmOverloads
fun Test2.testMemberExtensionFunction(a: Int, b: String = getString(), c: Double, d: Float = 1.0f, e: Boolean): Int = a
}
public class Test2 @JvmOverloads constructor(a: Int, b: String = getString(), c: Double, d: Float = 1.0f, e: Boolean) {
companion object {
@JvmOverloads
fun testCompanionFunction(a: Int, b: String = getString(), c: Double, d: Float = 1.0f, e: Boolean): Int = a
@JvmOverloads @JvmStatic
fun testStaticCompanionFunction(a: Int, b: String = getString(), c: Double, d: Float = 1.0f, e: Boolean): Int = a
}
}
public class GenericTest<T> @JvmOverloads constructor(a: Int = 1, b: T, c: String = "Hello world", d: T) {
@JvmOverloads
fun testMemberFunction(a: Int = 1, b: T, c: String = "Hello world", d: T): Int = a
fun useSpecialised(spec1: GenericTest<Float>, spec2: GenericTest<Double>) {
spec1.testMemberFunction(1, 1.0f, "Hello world", 2.0f)
spec2.testMemberFunction(1, 1.0, "Hello world", 2.0)
}
}
@JvmOverloads
fun Test.testExtensionFunction(a: Int, b: String = getString(), c: Double, d: Float = 1.0f, e: Boolean): Int = a
| java/ql/test/kotlin/library-tests/jvmoverloads-annotation/test.kt | 1840232138 |
package io.polymorphicpanda.zerofx.template.helpers
import javafx.beans.property.BooleanProperty
import javafx.scene.Node
import javafx.scene.control.Label
internal fun <K: Node, T: Builder<K>> builder(parent: Builder<*>?, builder: T, block: T.() -> Unit): K {
return builder.run {
block.invoke(this)
if (parent != null && parent is PaneBuilder) {
parent.add(this.node)
}
node
}
}
fun builder(block: PaneBuilder<*>.() -> Unit) = BuilderDelegate(block)
fun Builder<*>.stackPane(block: StackPaneBuilder.() -> Unit) = builder(this, StackPaneBuilder(), block)
fun Builder<*>.borderPane(block: BorderPaneBuilder.() -> Unit) = builder(this, BorderPaneBuilder(), block)
fun Builder<*>.vbox(block: VBoxBuilder.() -> Unit) = builder(this, VBoxBuilder(), block)
fun Builder<*>.hbox(block: HBoxBuilder.() -> Unit) = builder(this, HBoxBuilder(), block)
fun Builder<*>.label(text: String = "", block: LabelBuilder.() -> Unit = {})
= builder(this, LabelBuilder(Label(text)), block)
fun Builder<*>.button(block: ButtonBuilder.() -> Unit) = builder(this, ButtonBuilder(), block)
fun <T> Builder<*>.listView(block: ListViewBuilder<T>.() -> Unit) = builder(this, ListViewBuilder(), block)
fun Builder<*>.textField(block: TextFieldBuilder.() -> Unit) = builder(this, TextFieldBuilder(), block)
fun Builder<*>.textArea(block: TextAreaBuilder.() -> Unit) = builder(this, TextAreaBuilder(), block)
fun switch(condition: BooleanProperty) {
}
| zerofx-view-helpers/src/main/kotlin/io/polymorphicpanda/zerofx/template/helpers/Dsl.kt | 3491166593 |
/**
* Copyright (C) 2017 Cesar Valiente & Corey Shaw
*
* https://github.com/CesarValiente
* https://github.com/coshaw
*
* 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.cesarvaliente.kunidirectional.itemslist
import com.cesarvaliente.kunidirectional.ControllerView
import com.cesarvaliente.kunidirectional.store.DeleteAction.DeleteItemAction
import com.cesarvaliente.kunidirectional.store.Item
import com.cesarvaliente.kunidirectional.store.Navigation
import com.cesarvaliente.kunidirectional.store.NavigationAction.EditItemScreenAction
import com.cesarvaliente.kunidirectional.store.ReadAction.FetchItemsAction
import com.cesarvaliente.kunidirectional.store.State
import com.cesarvaliente.kunidirectional.store.Store
import com.cesarvaliente.kunidirectional.store.ThreadExecutor
import com.cesarvaliente.kunidirectional.store.UpdateAction.ReorderItemsAction
import com.cesarvaliente.kunidirectional.store.UpdateAction.UpdateFavoriteAction
import java.lang.ref.WeakReference
class ItemsControllerView(
val itemsViewCallback: WeakReference<ItemsViewCallback>,
store: Store,
mainThread: ThreadExecutor? = null)
: ControllerView(store, mainThread) {
fun fetchItems() =
store.dispatch(FetchItemsAction())
fun toEditItemScreen(item: Item) =
store.dispatch(EditItemScreenAction(item))
fun reorderItems(items: List<Item>) =
store.dispatch(ReorderItemsAction(items))
fun changeFavoriteStatus(item: Item) =
store.dispatch(UpdateFavoriteAction(localId = item.localId, favorite = !item.favorite))
fun deleteItem(item: Item) =
store.dispatch(DeleteItemAction(item.localId))
override fun handleState(state: State) {
when (state.navigation) {
Navigation.ITEMS_LIST -> itemsViewCallback.get()?.updateItems(state.itemsListScreen.items)
Navigation.EDIT_ITEM -> itemsViewCallback.get()?.goToEditItem()
}
}
} | app/src/main/kotlin/com/cesarvaliente/kunidirectional/itemslist/ItemsControllerView.kt | 154265068 |
package com.mgaetan89.showsrage.fragment
import android.app.SearchManager
import android.content.ComponentName
import android.content.Intent
import android.content.res.ColorStateList
import android.graphics.Bitmap
import android.graphics.BitmapFactory
import android.graphics.Color
import android.graphics.drawable.Drawable
import android.net.Uri
import android.os.Bundle
import android.support.customtabs.CustomTabsClient
import android.support.customtabs.CustomTabsIntent
import android.support.customtabs.CustomTabsServiceConnection
import android.support.customtabs.CustomTabsSession
import android.support.v4.app.Fragment
import android.support.v4.app.FragmentActivity
import android.support.v4.content.ContextCompat
import android.support.v4.view.ViewCompat
import android.support.v4.widget.SwipeRefreshLayout
import android.support.v7.app.AlertDialog
import android.support.v7.graphics.Palette
import android.text.format.DateUtils
import android.view.LayoutInflater
import android.view.Menu
import android.view.MenuInflater
import android.view.MenuItem
import android.view.View
import android.view.ViewGroup
import android.widget.ImageView
import com.mgaetan89.showsrage.Constants
import com.mgaetan89.showsrage.R
import com.mgaetan89.showsrage.activity.MainActivity
import com.mgaetan89.showsrage.extension.deleteShow
import com.mgaetan89.showsrage.extension.getShow
import com.mgaetan89.showsrage.extension.saveShow
import com.mgaetan89.showsrage.extension.toInt
import com.mgaetan89.showsrage.extension.toRelativeDate
import com.mgaetan89.showsrage.helper.GenericCallback
import com.mgaetan89.showsrage.helper.ImageLoader
import com.mgaetan89.showsrage.helper.Utils
import com.mgaetan89.showsrage.model.GenericResponse
import com.mgaetan89.showsrage.model.ImageType
import com.mgaetan89.showsrage.model.Indexer
import com.mgaetan89.showsrage.model.Show
import com.mgaetan89.showsrage.model.SingleShow
import com.mgaetan89.showsrage.network.SickRageApi
import io.realm.Realm
import io.realm.RealmChangeListener
import io.realm.RealmList
import kotlinx.android.synthetic.main.fragment_show_overview.show_airs
import kotlinx.android.synthetic.main.fragment_show_overview.show_banner
import kotlinx.android.synthetic.main.fragment_show_overview.show_fan_art
import kotlinx.android.synthetic.main.fragment_show_overview.show_genre
import kotlinx.android.synthetic.main.fragment_show_overview.show_imdb
import kotlinx.android.synthetic.main.fragment_show_overview.show_language_country
import kotlinx.android.synthetic.main.fragment_show_overview.show_location
import kotlinx.android.synthetic.main.fragment_show_overview.show_name
import kotlinx.android.synthetic.main.fragment_show_overview.show_network
import kotlinx.android.synthetic.main.fragment_show_overview.show_next_episode_date
import kotlinx.android.synthetic.main.fragment_show_overview.show_poster
import kotlinx.android.synthetic.main.fragment_show_overview.show_quality
import kotlinx.android.synthetic.main.fragment_show_overview.show_status
import kotlinx.android.synthetic.main.fragment_show_overview.show_subtitles
import kotlinx.android.synthetic.main.fragment_show_overview.show_the_tvdb
import kotlinx.android.synthetic.main.fragment_show_overview.show_web_search
import kotlinx.android.synthetic.main.fragment_show_overview.swipe_refresh
import retrofit.Callback
import retrofit.RetrofitError
import retrofit.client.Response
import java.lang.ref.WeakReference
class ShowOverviewFragment : Fragment(), Callback<SingleShow>, View.OnClickListener, ImageLoader.OnImageResult, SwipeRefreshLayout.OnRefreshListener, Palette.PaletteAsyncListener, RealmChangeListener<Show> {
private val indexerId by lazy { this.arguments!!.getInt(Constants.Bundle.INDEXER_ID) }
private var pauseMenu: MenuItem? = null
private lateinit var realm: Realm
private var resumeMenu: MenuItem? = null
private var serviceConnection: ServiceConnection? = null
private lateinit var show: Show
private var tabSession: CustomTabsSession? = null
init {
this.setHasOptionsMenu(true)
}
override fun failure(error: RetrofitError?) {
this.swipe_refresh?.isRefreshing = false
error?.printStackTrace()
}
fun getSetShowQualityCallback() = GenericCallback(this.activity)
override fun onChange(show: Show) {
if (!show.isLoaded || !show.isValid) {
return
}
if (this.serviceConnection == null) {
this.context?.let {
this.serviceConnection = ServiceConnection(this)
CustomTabsClient.bindCustomTabsService(it, "com.android.chrome", this.serviceConnection)
}
}
this.activity?.title = show.showName
val nextEpisodeAirDate = show.nextEpisodeAirDate
this.showHidePauseResumeMenus(show.paused == 0)
val airs = show.airs
this.show_airs?.text = this.getString(R.string.airs, if (airs.isNullOrEmpty()) "N/A" else airs)
this.show_airs?.visibility = View.VISIBLE
ImageLoader.load(this.show_banner, SickRageApi.instance.getImageUrl(ImageType.BANNER, show.tvDbId, Indexer.TVDB), false, null, this)
this.show_banner?.contentDescription = show.showName
ImageLoader.load(this.show_fan_art, SickRageApi.instance.getImageUrl(ImageType.FAN_ART, show.tvDbId, Indexer.TVDB), false, null, this)
this.show_fan_art?.contentDescription = show.showName
val genresList = show.genre
if (genresList?.isNotEmpty() == true) {
val genres = genresList.joinToString()
this.show_genre?.text = this.getString(R.string.genre, genres)
this.show_genre?.visibility = View.VISIBLE
} else {
this.show_genre?.visibility = View.GONE
}
this.show_imdb?.visibility = if (show.imdbId.isNullOrEmpty()) View.GONE else View.VISIBLE
this.show_language_country?.text = this.getString(R.string.language_value, show.language)
this.show_language_country?.visibility = View.VISIBLE
val location = show.location
this.show_location?.text = this.getString(R.string.location, if (location.isNullOrEmpty()) "N/A" else location)
this.show_location?.visibility = View.VISIBLE
this.show_name?.text = show.showName
this.show_name?.visibility = View.VISIBLE
if (nextEpisodeAirDate.isEmpty()) {
this.show_next_episode_date?.visibility = View.GONE
} else {
this.show_next_episode_date?.text = this.getString(R.string.next_episode, nextEpisodeAirDate.toRelativeDate("yyyy-MM-dd", DateUtils.DAY_IN_MILLIS))
this.show_next_episode_date?.visibility = View.VISIBLE
}
this.show_network?.text = this.getString(R.string.network, show.network)
this.show_network?.visibility = View.VISIBLE
ImageLoader.load(this.show_poster, SickRageApi.instance.getImageUrl(ImageType.POSTER, show.tvDbId, Indexer.TVDB), false, this, null)
this.show_poster?.contentDescription = show.showName
val quality = show.quality
if ("custom".equals(quality, true)) {
val qualityDetails = show.qualityDetails
val allowed = this.getTranslatedQualities(qualityDetails?.initial, true).joinToString()
val preferred = this.getTranslatedQualities(qualityDetails?.archive, false).joinToString()
this.show_quality?.text = this.getString(R.string.quality_custom, allowed, preferred)
} else {
this.show_quality?.text = this.getString(R.string.quality, quality)
}
this.show_quality?.visibility = View.VISIBLE
if (nextEpisodeAirDate.isEmpty()) {
val status = show.getStatusTranslationResource()
this.show_status?.text = if (status != 0) this.getString(status) else show.status
this.show_status?.visibility = View.VISIBLE
} else {
this.show_status?.visibility = View.GONE
}
this.show_subtitles?.text = this.getString(R.string.subtitles_value, this.getString(if (show.subtitles == 0) R.string.no else R.string.yes))
this.show_subtitles?.visibility = View.VISIBLE
}
override fun onClick(view: View?) {
if (view == null || !this.show.isValid) {
return
}
val activity = this.activity
var color = if (activity != null) ContextCompat.getColor(activity, R.color.primary) else Color.BLUE
color = (activity as? MainActivity)?.themeColors?.primary ?: color
val url = when (view.id) {
R.id.show_imdb -> "http://www.imdb.com/title/${this.show.imdbId}"
R.id.show_the_tvdb -> "http://thetvdb.com/?tab=series&id=${this.show.tvDbId}"
R.id.show_web_search -> {
val intent = Intent(Intent.ACTION_WEB_SEARCH)
intent.putExtra(SearchManager.QUERY, this.show.showName)
this.startActivity(intent)
return
}
else -> return
}
val tabIntent = CustomTabsIntent.Builder(this.tabSession)
.addDefaultShareMenuItem()
.enableUrlBarHiding()
.setCloseButtonIcon(BitmapFactory.decodeResource(this.resources, R.drawable.ic_arrow_back_white_24dp))
.setShowTitle(true)
.setToolbarColor(color)
.build()
tabIntent.launchUrl(this.activity, Uri.parse(url))
}
override fun onCreateOptionsMenu(menu: Menu?, inflater: MenuInflater?) {
inflater?.inflate(R.menu.show_overview, menu)
this.pauseMenu = menu?.findItem(R.id.menu_pause_show)
this.pauseMenu?.isVisible = false
this.resumeMenu = menu?.findItem(R.id.menu_resume_show)
this.resumeMenu?.isVisible = false
}
override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View?
= inflater.inflate(R.layout.fragment_show_overview, container, false)
override fun onDestroy() {
val activity = this.activity
if (activity is MainActivity) {
activity.resetThemeColors()
}
if (this.serviceConnection != null) {
this.context?.unbindService(this.serviceConnection)
}
super.onDestroy()
}
override fun onGenerated(palette: Palette) {
val context = this.context ?: return
val activity = this.activity
val colors = Utils.getThemeColors(context, palette)
val colorPrimary = colors.primary
if (activity is MainActivity) {
activity.themeColors = colors
}
if (colorPrimary == 0) {
return
}
val colorStateList = ColorStateList.valueOf(colorPrimary)
val textColor = Utils.getContrastColor(colorPrimary)
this.show_imdb?.let {
ViewCompat.setBackgroundTintList(it, colorStateList)
it.setTextColor(textColor)
}
this.show_the_tvdb?.let {
ViewCompat.setBackgroundTintList(it, colorStateList)
it.setTextColor(textColor)
}
this.show_web_search?.let {
ViewCompat.setBackgroundTintList(it, colorStateList)
it.setTextColor(textColor)
}
}
override fun onImageError(imageView: ImageView, errorDrawable: Drawable?) {
val parent = imageView.parent
if (parent is View) {
parent.visibility = View.GONE
}
}
override fun onImageReady(imageView: ImageView, resource: Bitmap) {
val parent = imageView.parent
if (parent is View) {
parent.visibility = View.VISIBLE
}
}
override fun onOptionsItemSelected(item: MenuItem?) = when (item?.itemId) {
R.id.menu_change_quality -> {
this.changeQuality()
true
}
R.id.menu_delete_show -> {
this.deleteShow()
true
}
R.id.menu_pause_show -> {
this.pauseOrResumeShow(true)
true
}
R.id.menu_rescan_show -> {
this.rescanShow()
true
}
R.id.menu_resume_show -> {
this.pauseOrResumeShow(false)
true
}
R.id.menu_update_show -> {
this.updateShow()
true
}
else -> super.onOptionsItemSelected(item)
}
override fun onRefresh() {
this.swipe_refresh?.isRefreshing = true
val indexerId = this.arguments?.getInt(Constants.Bundle.INDEXER_ID) ?: return
SickRageApi.instance.services?.getShow(indexerId, this)
}
override fun onResume() {
super.onResume()
this.onRefresh()
}
override fun onStart() {
super.onStart()
this.realm = Realm.getDefaultInstance()
this.show = this.realm.getShow(this.indexerId, this)
}
override fun onStop() {
if (this.show.isValid) {
this.show.removeAllChangeListeners()
}
this.realm.close()
super.onStop()
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
this.show_imdb?.setOnClickListener(this)
this.show_the_tvdb?.setOnClickListener(this)
this.show_web_search?.setOnClickListener(this)
this.swipe_refresh?.setColorSchemeResources(R.color.accent)
this.swipe_refresh?.setOnRefreshListener(this)
this.checkSupportWebSearch()
}
override fun success(singleShow: SingleShow?, response: Response?) {
this.swipe_refresh?.isRefreshing = false
val show = singleShow?.data ?: return
Realm.getDefaultInstance().use {
it.saveShow(show)
}
}
private fun changeQuality() {
ChangeQualityFragment.newInstance(this.indexerId)
.show(this.childFragmentManager, "change_quality")
}
private fun checkSupportWebSearch() {
val webSearchIntent = Intent(Intent.ACTION_WEB_SEARCH)
val manager = this.context?.packageManager
val activities = manager?.queryIntentActivities(webSearchIntent, 0).orEmpty()
this.show_web_search?.visibility = if (activities.isNotEmpty()) View.VISIBLE else View.GONE
}
private fun deleteShow() {
val activity = this.activity
if (activity == null || !this.show.isLoaded) {
return
}
val indexerId = this.indexerId
val callback = DeleteShowCallback(activity, indexerId)
AlertDialog.Builder(activity)
.setTitle(this.getString(R.string.delete_show_title, this.show.showName))
.setMessage(R.string.delete_show_message)
.setPositiveButton(R.string.keep) { _, _ ->
SickRageApi.instance.services?.deleteShow(indexerId, 0, callback)
}
.setNegativeButton(R.string.delete) { _, _ ->
SickRageApi.instance.services?.deleteShow(indexerId, 1, callback)
}
.setNeutralButton(R.string.cancel, null)
.show()
}
private fun getTranslatedQualities(qualities: RealmList<String>?, allowed: Boolean): List<String> {
val translatedQualities = mutableListOf<String>()
if (qualities == null || qualities.isEmpty()) {
return translatedQualities
}
val keys = if (allowed) {
resources.getStringArray(R.array.allowed_qualities_keys).toList()
} else {
resources.getStringArray(R.array.allowed_qualities_keys).toList()
}
val values = if (allowed) {
resources.getStringArray(R.array.allowed_qualities_values).toList()
} else {
resources.getStringArray(R.array.allowed_qualities_values).toList()
}
qualities.forEach {
val position = keys.indexOf(it)
if (position != -1) {
// Skip the "Ignore" first item
translatedQualities.add(values[position + 1])
}
}
return translatedQualities
}
private fun pauseOrResumeShow(pause: Boolean) {
this.showHidePauseResumeMenus(!pause)
SickRageApi.instance.services?.pauseShow(this.indexerId, pause.toInt(), object : GenericCallback(this.activity) {
override fun failure(error: RetrofitError?) {
super.failure(error)
showHidePauseResumeMenus(pause)
}
})
}
private fun rescanShow() {
SickRageApi.instance.services?.rescanShow(this.indexerId, GenericCallback(this.activity))
}
private fun showHidePauseResumeMenus(isPause: Boolean) {
this.pauseMenu?.isVisible = isPause
this.resumeMenu?.isVisible = !isPause
}
private fun updateShow() {
SickRageApi.instance.services?.updateShow(this.indexerId, GenericCallback(this.activity))
}
private class DeleteShowCallback(activity: FragmentActivity, val indexerId: Int) : GenericCallback(activity) {
override fun success(genericResponse: GenericResponse?, response: Response?) {
super.success(genericResponse, response)
Realm.getDefaultInstance().use {
it.deleteShow(this.indexerId)
}
val activity = this.getActivity() ?: return
val intent = Intent(activity, MainActivity::class.java)
activity.startActivity(intent)
}
}
private class ServiceConnection(fragment: ShowOverviewFragment) : CustomTabsServiceConnection() {
private val fragmentReference = WeakReference(fragment)
override fun onCustomTabsServiceConnected(componentName: ComponentName?, customTabsClient: CustomTabsClient?) {
customTabsClient?.warmup(0L)
val fragment = this.fragmentReference.get() ?: return
fragment.tabSession = customTabsClient?.newSession(null)
if (fragment.show.isValid) {
fragment.tabSession?.mayLaunchUrl(Uri.parse("http://www.imdb.com/title/${fragment.show.imdbId}"), null, null)
fragment.tabSession?.mayLaunchUrl(Uri.parse("http://thetvdb.com/?tab=series&id=${fragment.show.tvDbId}"), null, null)
}
}
override fun onServiceDisconnected(name: ComponentName?) {
this.fragmentReference.clear()
}
}
}
| app/src/main/kotlin/com/mgaetan89/showsrage/fragment/ShowOverviewFragment.kt | 1126029486 |
package top.zbeboy.isy.service.system
import com.alibaba.fastjson.JSON
import org.jooq.*
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Propagation
import org.springframework.transaction.annotation.Transactional
import org.springframework.util.ObjectUtils
import org.springframework.util.StringUtils
import top.zbeboy.isy.domain.Tables.SYSTEM_ALERT
import top.zbeboy.isy.domain.Tables.SYSTEM_ALERT_TYPE
import top.zbeboy.isy.domain.tables.daos.SystemAlertDao
import top.zbeboy.isy.domain.tables.pojos.SystemAlert
import top.zbeboy.isy.service.util.DateTimeUtils
import top.zbeboy.isy.service.util.SQLQueryUtils
import top.zbeboy.isy.web.bean.system.alert.SystemAlertBean
import top.zbeboy.isy.web.util.PaginationUtils
import java.sql.Timestamp
import java.util.*
import javax.annotation.Resource
/**
* Created by zbeboy 2017-11-07 .
**/
@Service("systemAlertService")
@Transactional(propagation = Propagation.SUPPORTS, readOnly = true)
open class SystemAlertServiceImpl @Autowired constructor(dslContext: DSLContext) : SystemAlertService {
private val create: DSLContext = dslContext
@Resource
open lateinit var systemAlertDao: SystemAlertDao
override fun findByUsernameAndId(username: String, id: String): Optional<Record> {
return create.select()
.from(SYSTEM_ALERT)
.join(SYSTEM_ALERT_TYPE)
.on(SYSTEM_ALERT.SYSTEM_ALERT_TYPE_ID.eq(SYSTEM_ALERT_TYPE.SYSTEM_ALERT_TYPE_ID))
.where(SYSTEM_ALERT.USERNAME.eq(username).and(SYSTEM_ALERT.SYSTEM_ALERT_ID.eq(id)))
.fetchOptional()
}
override fun findByUsernameAndLinkIdAndSystemAlertTypeId(username: String, linkId: String, systemAlertTypeId: Int): Optional<Record> {
return create.select()
.from(SYSTEM_ALERT)
.where(SYSTEM_ALERT.USERNAME.eq(username).and(SYSTEM_ALERT.LINK_ID.eq(linkId)).and(SYSTEM_ALERT.SYSTEM_ALERT_TYPE_ID.eq(systemAlertTypeId)))
.fetchOptional()
}
override fun findAllByPageForShow(pageNum: Int, pageSize: Int, username: String, isSee: Boolean): Result<Record> {
val b: Byte = if (isSee) {
1
} else {
0
}
return create.select()
.from(SYSTEM_ALERT)
.join(SYSTEM_ALERT_TYPE)
.on(SYSTEM_ALERT.SYSTEM_ALERT_TYPE_ID.eq(SYSTEM_ALERT_TYPE.SYSTEM_ALERT_TYPE_ID))
.where(SYSTEM_ALERT.USERNAME.eq(username).and(SYSTEM_ALERT.IS_SEE.eq(b)))
.orderBy(SYSTEM_ALERT.ALERT_DATE.desc())
.limit((pageNum - 1) * pageSize, pageSize)
.fetch()
}
override fun countAllForShow(username: String, isSee: Boolean): Int {
val b: Byte = if (isSee) {
1
} else {
0
}
val record = create.selectCount()
.from(SYSTEM_ALERT)
.where(SYSTEM_ALERT.USERNAME.eq(username).and(SYSTEM_ALERT.IS_SEE.eq(b)))
.fetchOne()
return record.value1()
}
override fun findAllByPage(paginationUtils: PaginationUtils, systemAlertBean: SystemAlertBean): Result<Record> {
val pageNum = paginationUtils.getPageNum()
val pageSize = paginationUtils.getPageSize()
var a = searchCondition(paginationUtils)
a = otherCondition(a, systemAlertBean)
return create.select()
.from(SYSTEM_ALERT)
.join(SYSTEM_ALERT_TYPE)
.on(SYSTEM_ALERT.SYSTEM_ALERT_TYPE_ID.eq(SYSTEM_ALERT_TYPE.SYSTEM_ALERT_TYPE_ID))
.where(a)
.orderBy(SYSTEM_ALERT.ALERT_DATE.desc())
.limit((pageNum - 1) * pageSize, pageSize)
.fetch()
}
override fun dealData(paginationUtils: PaginationUtils, records: Result<Record>, systemAlertBean: SystemAlertBean): List<SystemAlertBean> {
var systemAlertBeens: List<SystemAlertBean> = ArrayList()
if (records.isNotEmpty) {
systemAlertBeens = records.into(SystemAlertBean::class.java)
systemAlertBeens.forEach { i -> i.alertDateStr = DateTimeUtils.formatDate(i.alertDate, "yyyy年MM月dd日 HH:mm:ss") }
paginationUtils.setTotalDatas(countByCondition(paginationUtils, systemAlertBean))
}
return systemAlertBeens
}
override fun countByCondition(paginationUtils: PaginationUtils, systemAlertBean: SystemAlertBean): Int {
val count: Record1<Int>
var a = searchCondition(paginationUtils)
a = otherCondition(a, systemAlertBean)
count = if (ObjectUtils.isEmpty(a)) {
val selectJoinStep = create.selectCount()
.from(SYSTEM_ALERT)
selectJoinStep.fetchOne()
} else {
val selectConditionStep = create.selectCount()
.from(SYSTEM_ALERT)
.join(SYSTEM_ALERT_TYPE)
.on(SYSTEM_ALERT.SYSTEM_ALERT_TYPE_ID.eq(SYSTEM_ALERT_TYPE.SYSTEM_ALERT_TYPE_ID))
.where(a)
selectConditionStep.fetchOne()
}
return count.value1()
}
@Transactional(propagation = Propagation.REQUIRED, readOnly = false)
override fun save(systemAlert: SystemAlert) {
systemAlertDao.insert(systemAlert)
}
override fun deleteByAlertDate(timestamp: Timestamp) {
create.deleteFrom(SYSTEM_ALERT).where(SYSTEM_ALERT.ALERT_DATE.le(timestamp)).execute()
}
override fun update(systemAlert: SystemAlert) {
systemAlertDao.update(systemAlert)
}
/**
* 搜索条件
*
* @param paginationUtils 分页工具
* @return 条件
*/
fun searchCondition(paginationUtils: PaginationUtils): Condition? {
var a: Condition? = null
val search = JSON.parseObject(paginationUtils.getSearchParams())
if (!ObjectUtils.isEmpty(search)) {
val alertContent = StringUtils.trimWhitespace(search.getString("alertContent"))
if (StringUtils.hasLength(alertContent)) {
a = SYSTEM_ALERT.ALERT_CONTENT.like(SQLQueryUtils.likeAllParam(alertContent))
}
}
return a
}
/**
* 其它条件参数
*
* @param a 搜索条件
* @param systemAlertBean 额外参数
* @return 条件
*/
private fun otherCondition(a: Condition?, systemAlertBean: SystemAlertBean): Condition? {
var condition = a
if (!ObjectUtils.isEmpty(systemAlertBean)) {
if (StringUtils.hasLength(systemAlertBean.username)) {
condition = if (!ObjectUtils.isEmpty(condition)) {
condition!!.and(SYSTEM_ALERT.USERNAME.eq(systemAlertBean.username))
} else {
SYSTEM_ALERT.USERNAME.eq(systemAlertBean.username)
}
}
}
return condition
}
} | src/main/java/top/zbeboy/isy/service/system/SystemAlertServiceImpl.kt | 4182436792 |
package hamburg.remme.tinygit.domain.service
import hamburg.remme.tinygit.I18N
import hamburg.remme.tinygit.Refreshable
import hamburg.remme.tinygit.Service
import hamburg.remme.tinygit.TinyGit
import hamburg.remme.tinygit.domain.Repository
import hamburg.remme.tinygit.git.gitCommit
import hamburg.remme.tinygit.git.gitCommitAmend
import hamburg.remme.tinygit.git.gitHeadMessage
import hamburg.remme.tinygit.git.gitMergeMessage
import javafx.beans.property.SimpleStringProperty
import javafx.concurrent.Task
@Service
class CommitService : Refreshable {
val message = SimpleStringProperty("")
private lateinit var repository: Repository
fun setMergeMessage() {
if (message.get().isBlank()) message.set(gitMergeMessage(repository))
}
fun setHeadMessage() {
if (message.get().isBlank()) message.set(gitHeadMessage(repository))
}
fun commit(message: String, amend: Boolean, errorHandler: () -> Unit) {
TinyGit.run(I18N["commit.committing"], object : Task<Unit>() {
override fun call() {
if (amend) gitCommitAmend(repository, message)
else gitCommit(repository, message)
}
override fun succeeded() {
[email protected]("")
TinyGit.fireEvent()
}
override fun failed() = errorHandler()
})
}
override fun onRefresh(repository: Repository) {
this.repository = repository
}
override fun onRepositoryChanged(repository: Repository) {
this.repository = repository
}
override fun onRepositoryDeselected() {
}
}
| src/main/kotlin/hamburg/remme/tinygit/domain/service/CommitService.kt | 1095108046 |
package com.alexstyl.specialdates.contact
import android.LruCache
class ContactCache(maxSize: Int) {
private val cache: LruCache<Long, Contact> = LruCache(maxSize)
fun addContact(contact: Contact) {
cache.put(keyFor(contact), contact)
}
fun getContact(id: Long): Contact? = cache.get(id)
fun size(): Int = cache.size()
fun evictAll() {
cache.evictAll()
}
fun addContacts(contacts: Contacts) {
contacts.forEach {
cache.put(it.contactID, it)
}
}
private fun keyFor(contact: Contact): Long = contact.contactID
}
| memento/src/main/java/com/alexstyl/specialdates/contact/ContactCache.kt | 3347943406 |
package com.tinsuke.icekick.bundler
import android.os.Bundle
import java.io.Serializable
internal class SerializableBundler : Bundler<Serializable> {
override fun save(bundle: Bundle, key: String, value: Serializable?) = bundle.putSerializable(key, value as? Serializable)
override fun load(bundle: Bundle, key: String) = bundle.getSerializable(key)
}
| icekick/src/main/kotlin/com/tinsuke/icekick/bundler/SerializableBundler.kt | 904521907 |
package com.displee.util
import com.displee.cache.index.Index.Companion.WHIRLPOOL_SIZE
import java.io.InputStream
import java.io.OutputStream
private val CRC_TABLE = IntArray(256) {
var crc = it
for (i_84_ in 0..7) {
crc = if (crc and 0x1 == 1) {
crc ushr 1 xor 0x12477cdf.inv()
} else {
crc ushr 1
}
}
crc
}
fun ByteArray.generateCrc(offset: Int = 0, length: Int = size): Int {
var crc = -1
for (i in offset until length) {
crc = crc ushr 8 xor CRC_TABLE[crc xor this[i].toInt() and 0xff]
}
crc = crc xor -0x1
return crc
}
fun ByteArray.generateWhirlpool(offset: Int = 0, length: Int = size): ByteArray {
val source: ByteArray
if (offset > 0) {
source = ByteArray(length)
System.arraycopy(this, offset, source, 0, length)
} else {
source = this
}
val whirlpool = Whirlpool()
whirlpool.NESSIEinit()
whirlpool.NESSIEadd(source, (length * 8).toLong())
val digest = ByteArray(WHIRLPOOL_SIZE)
whirlpool.NESSIEfinalize(digest, 0)
return digest
}
fun InputStream.writeTo(to: OutputStream): Long {
val buf = ByteArray(0x1000)
var total: Long = 0
while (true) {
val r = read(buf)
if (r == -1) {
break
}
to.write(buf, 0, r)
total += r.toLong()
}
return total
}
fun String.hashCode317(): Int {
val upperCaseString = toUpperCase()
var hash = 0
for (element in upperCaseString) {
hash = hash * 61 + element.toInt() - 32
}
return hash
} | src/main/kotlin/com/displee/util/OtherExt.kt | 2657344116 |
package com.virtlink.editorservices.documentation
import java.io.Serializable
interface IDocumentationInfo : Serializable {
val text: String
} | aesi/src/main/kotlin/com/virtlink/editorservices/documentation/IDocumentationInfo.kt | 4191398846 |
package org.runestar.client.updater.mapper.std.classes
import org.runestar.client.common.startsWith
import org.runestar.client.updater.mapper.IdentityMapper
import org.runestar.client.updater.mapper.OrderMapper
import org.runestar.client.updater.mapper.DependsOn
import org.runestar.client.updater.mapper.MethodParameters
import org.runestar.client.updater.mapper.and
import org.runestar.client.updater.mapper.predicateOf
import org.runestar.client.updater.mapper.type
import org.runestar.client.updater.mapper.Class2
import org.runestar.client.updater.mapper.Field2
import org.runestar.client.updater.mapper.Instruction2
import org.runestar.client.updater.mapper.Method2
import org.objectweb.asm.Type
import java.awt.Component
import java.awt.Image
@DependsOn(AbstractRasterProvider::class)
class RasterProvider : IdentityMapper.Class() {
override val predicate = predicateOf<Class2> { it.superType == type<AbstractRasterProvider>() }
.and { it.interfaces.isEmpty() }
.and { it.instanceFields.any { it.type == Component::class.type } }
class component0 : IdentityMapper.InstanceField() {
override val predicate = predicateOf<Field2> { it.type == Component::class.type }
}
class image : IdentityMapper.InstanceField() {
override val predicate = predicateOf<Field2> { it.type == Image::class.type }
}
@MethodParameters("x", "y", "width", "height")
@DependsOn(AbstractRasterProvider.draw::class)
class draw : IdentityMapper.InstanceMethod() {
override val predicate = predicateOf<Method2> { it.mark == method<AbstractRasterProvider.draw>().mark }
}
@MethodParameters("x", "y")
@DependsOn(AbstractRasterProvider.drawFull::class)
class drawFull : IdentityMapper.InstanceMethod() {
override val predicate = predicateOf<Method2> { it.mark == method<AbstractRasterProvider.drawFull>().mark }
}
@MethodParameters("graphics", "x", "y", "width", "height")
@DependsOn(draw::class)
class draw0 : OrderMapper.InMethod.Method(draw::class, 0, 1) {
override val predicate = predicateOf<Instruction2> { it.isMethod && it.methodOwner == type<RasterProvider>() }
}
@MethodParameters("graphics", "x", "y")
@DependsOn(drawFull::class)
class drawFull0 : OrderMapper.InMethod.Method(drawFull::class, 0, 1) {
override val predicate = predicateOf<Instruction2> { it.isMethod && it.methodOwner == type<RasterProvider>() }
}
@MethodParameters("c")
class setComponent : IdentityMapper.InstanceMethod() {
override val predicate = predicateOf<Method2> { it.returnType == Type.VOID_TYPE }
.and { it.arguments.startsWith(Component::class.type) }
}
} | updater-mapper/src/main/java/org/runestar/client/updater/mapper/std/classes/RasterProvider.kt | 388427835 |
package com.virtlink.pie.structureoutline
import com.google.inject.name.Named
import com.virtlink.editorservices.ICancellationToken
import com.virtlink.editorservices.ScopeNames
import com.virtlink.editorservices.Span
import com.virtlink.editorservices.resources.IResourceManager
import com.virtlink.editorservices.structureoutline.*
import com.virtlink.editorservices.symbols.ISymbol
import com.virtlink.pie.IBuildManagerProvider
import mb.pie.runtime.core.BuildApp
import java.io.Serializable
import java.net.URI
class PieStructureOutlineService(
private val buildManagerProvider: IBuildManagerProvider,
private val resourceManager: IResourceManager,
@Named(PieStructureOutlineService.ID) private val builderId: String
) : IStructureOutlineService {
companion object {
const val ID: String = "StructureOutlineBuilder.ID"
}
data class Input(val document: URI) : Serializable
data class StructureOutlineElement(
val children: List<StructureOutlineElement>,
override val label: String,
override val nameSpan: Span? = null,
override val scopes: ScopeNames = ScopeNames(),
override val isLeaf: Boolean? = null)
: IStructureOutlineElement
data class StructureTree(val roots: List<StructureOutlineElement>): Serializable
override fun configure(configuration: IStructureOutlineConfiguration) {
// Nothing to do.
}
override fun getRoots(
document: URI,
cancellationToken: ICancellationToken?)
: IStructureOutlineInfo? {
return StructureOutlineInfo(getTree(document).roots)
}
override fun getChildren(
document: URI,
node: IStructureOutlineElement,
cancellationToken: ICancellationToken?)
: IStructureOutlineInfo? {
return StructureOutlineInfo((node as StructureOutlineElement).children)
}
private fun getTree(document: URI): StructureTree {
val input = PieStructureOutlineService.Input(document)
val project = this.resourceManager.getProjectOf(document)!!
val app = BuildApp<PieStructureOutlineService.Input, StructureTree>(this.builderId, input)
val manager = buildManagerProvider.getBuildManager(project)
return manager.build(app)
}
} | pie/src/main/kotlin/com/virtlink/pie/structureoutline/PieStructureOutlineService.kt | 1494173094 |
// Copyright 2000-2021 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.
package com.intellij.openapi.vcs.ui
import com.intellij.openapi.Disposable
import com.intellij.openapi.ui.ValidationInfo
import com.intellij.openapi.vcs.CheckoutProvider
import com.intellij.openapi.vcs.VcsBundle
import com.intellij.openapi.vcs.ui.cloneDialog.VcsCloneDialogComponentStateListener
import com.intellij.util.concurrency.annotations.RequiresEdt
import org.jetbrains.annotations.Nls
import javax.swing.JComponent
/**
* Provides UI and dialog action handling for specific VCS
*/
interface VcsCloneComponent : Disposable {
/**
* Component that would be placed on center of dialog panel
*/
fun getView(): JComponent
fun doClone(listener: CheckoutProvider.Listener)
fun isOkEnabled(): Boolean
fun doValidateAll(): List<ValidationInfo>
@Nls
fun getOkButtonText(): String = VcsBundle.message("clone.dialog.clone.button")
fun getPreferredFocusedComponent(): JComponent?
@RequiresEdt
fun onComponentSelected(dialogStateListener: VcsCloneDialogComponentStateListener) {
}
}
| platform/vcs-api/src/com/intellij/openapi/vcs/ui/VcsCloneComponent.kt | 4215010324 |
package com.example.unittesting.login.model
class LoginValidator {
companion object {
val EMPTY = ""
val MIN_PASSWORD_LENGTH = 6
}
fun validateLogin(login: String): Boolean {
return login != EMPTY
}
fun validatePassword(password: String): Boolean {
return password.length >= MIN_PASSWORD_LENGTH
}
}
| app/src/main/kotlin/com/example/unittesting/login/model/LoginValidator.kt | 617014126 |
package test
import IdCacheKeyGenerator
import codegen.models.HeroAndFriendsWithFragmentsQuery
import codegen.models.HeroAndFriendsWithTypenameQuery
import codegen.models.fragment.HeroWithFriendsFragment
import codegen.models.fragment.HeroWithFriendsFragmentImpl
import codegen.models.fragment.HumanWithIdFragment
import codegen.models.fragment.HumanWithIdFragmentImpl
import com.apollographql.apollo3.ApolloClient
import com.apollographql.apollo3.annotations.ApolloExperimental
import com.apollographql.apollo3.cache.normalized.ApolloStore
import com.apollographql.apollo3.cache.normalized.api.CacheKey
import com.apollographql.apollo3.cache.normalized.api.MemoryCacheFactory
import com.apollographql.apollo3.cache.normalized.store
import com.apollographql.apollo3.mockserver.MockServer
import com.apollographql.apollo3.mockserver.enqueue
import com.apollographql.apollo3.testing.runTest
import testFixtureToUtf8
import kotlin.test.Test
import kotlin.test.assertEquals
@OptIn(ApolloExperimental::class)
class StoreTest {
private lateinit var mockServer: MockServer
private lateinit var apolloClient: ApolloClient
private lateinit var store: ApolloStore
private suspend fun setUp() {
store = ApolloStore(
normalizedCacheFactory = MemoryCacheFactory(),
cacheKeyGenerator = IdCacheKeyGenerator
)
mockServer = MockServer()
apolloClient = ApolloClient.Builder().serverUrl(mockServer.url()).store(store).build()
}
private suspend fun tearDown() {
mockServer.stop()
}
@Test
fun readFragmentFromStore() = runTest(before = { setUp() }, after = { tearDown() }) {
mockServer.enqueue(testFixtureToUtf8("HeroAndFriendsWithTypename.json"))
apolloClient.query(HeroAndFriendsWithTypenameQuery()).execute()
val heroWithFriendsFragment = store.readFragment(
HeroWithFriendsFragmentImpl(),
CacheKey("2001"),
)
assertEquals(heroWithFriendsFragment.id, "2001")
assertEquals(heroWithFriendsFragment.name, "R2-D2")
assertEquals(heroWithFriendsFragment.friends?.size, 3)
assertEquals(heroWithFriendsFragment.friends?.get(0)?.fragments?.humanWithIdFragment?.id, "1000")
assertEquals(heroWithFriendsFragment.friends?.get(0)?.fragments?.humanWithIdFragment?.name, "Luke Skywalker")
assertEquals(heroWithFriendsFragment.friends?.get(1)?.fragments?.humanWithIdFragment?.id, "1002")
assertEquals(heroWithFriendsFragment.friends?.get(1)?.fragments?.humanWithIdFragment?.name, "Han Solo")
assertEquals(heroWithFriendsFragment.friends?.get(2)?.fragments?.humanWithIdFragment?.id, "1003")
assertEquals(heroWithFriendsFragment.friends?.get(2)?.fragments?.humanWithIdFragment?.name, "Leia Organa")
var fragment = store.readFragment(
HumanWithIdFragmentImpl(),
CacheKey("1000"),
)
assertEquals(fragment.id, "1000")
assertEquals(fragment.name, "Luke Skywalker")
fragment = store.readFragment(
HumanWithIdFragmentImpl(),
CacheKey("1002"),
)
assertEquals(fragment.id, "1002")
assertEquals(fragment.name, "Han Solo")
fragment = store.readFragment(
HumanWithIdFragmentImpl(),
CacheKey("1003"),
)
assertEquals(fragment.id, "1003")
assertEquals(fragment.name, "Leia Organa")
}
/**
* Modify the store by writing fragments
*/
@Test
fun fragments() = runTest(before = { setUp() }, after = { tearDown() }) {
mockServer.enqueue(testFixtureToUtf8("HeroAndFriendsNamesWithIDs.json"))
val query = HeroAndFriendsWithFragmentsQuery()
var response = apolloClient.query(query).execute()
assertEquals(response.data?.hero?.__typename, "Droid")
assertEquals(response.data?.hero?.fragments?.heroWithFriendsFragment?.id, "2001")
assertEquals(response.data?.hero?.fragments?.heroWithFriendsFragment?.name, "R2-D2")
assertEquals(response.data?.hero?.fragments?.heroWithFriendsFragment?.friends?.size, 3)
assertEquals(response.data?.hero?.fragments?.heroWithFriendsFragment?.friends?.get(0)?.fragments?.humanWithIdFragment?.id, "1000")
assertEquals(response.data?.hero?.fragments?.heroWithFriendsFragment?.friends?.get(0)?.fragments?.humanWithIdFragment?.name, "Luke Skywalker")
assertEquals(response.data?.hero?.fragments?.heroWithFriendsFragment?.friends?.get(1)?.fragments?.humanWithIdFragment?.id, "1002")
assertEquals(response.data?.hero?.fragments?.heroWithFriendsFragment?.friends?.get(1)?.fragments?.humanWithIdFragment?.name, "Han Solo")
assertEquals(response.data?.hero?.fragments?.heroWithFriendsFragment?.friends?.get(2)?.fragments?.humanWithIdFragment?.id, "1003")
assertEquals(response.data?.hero?.fragments?.heroWithFriendsFragment?.friends?.get(2)?.fragments?.humanWithIdFragment?.name, "Leia Organa")
store.writeFragment(
HeroWithFriendsFragmentImpl(),
CacheKey("2001"),
HeroWithFriendsFragment(
id = "2001",
name = "R222-D222",
friends = listOf(
HeroWithFriendsFragment.Friend(
__typename = "Human",
fragments = HeroWithFriendsFragment.Friend.Fragments(
humanWithIdFragment = HumanWithIdFragment(
id = "1000",
name = "SuperMan"
)
)
),
HeroWithFriendsFragment.Friend(
__typename = "Human",
fragments = HeroWithFriendsFragment.Friend.Fragments(
humanWithIdFragment = HumanWithIdFragment(
id = "1002",
name = "Han Solo"
)
)
),
)
),
)
store.writeFragment(
HumanWithIdFragmentImpl(),
CacheKey("1002"),
HumanWithIdFragment(
id = "1002",
name = "Beast"
),
)
// Values should have changed
response = apolloClient.query(query).execute()
assertEquals(response.data?.hero?.__typename, "Droid")
assertEquals(response.data?.hero?.fragments?.heroWithFriendsFragment?.id, "2001")
assertEquals(response.data?.hero?.fragments?.heroWithFriendsFragment?.name, "R222-D222")
assertEquals(response.data?.hero?.fragments?.heroWithFriendsFragment?.friends?.size, 2)
assertEquals(response.data?.hero?.fragments?.heroWithFriendsFragment?.friends?.get(0)?.fragments?.humanWithIdFragment?.id, "1000")
assertEquals(response.data?.hero?.fragments?.heroWithFriendsFragment?.friends?.get(0)?.fragments?.humanWithIdFragment?.name, "SuperMan")
assertEquals(response.data?.hero?.fragments?.heroWithFriendsFragment?.friends?.get(1)?.fragments?.humanWithIdFragment?.id, "1002")
assertEquals(response.data?.hero?.fragments?.heroWithFriendsFragment?.friends?.get(1)?.fragments?.humanWithIdFragment?.name, "Beast")
}
} | tests/models-compat/src/commonTest/kotlin/test/StoreTest.kt | 1428081618 |
// 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.
package com.intellij.refactoring.extractMethod.newImpl.inplace
import com.intellij.codeInsight.template.impl.TemplateManagerImpl
import com.intellij.codeInsight.template.impl.TemplateState
import com.intellij.ide.util.PropertiesComponent
import com.intellij.java.refactoring.JavaRefactoringBundle
import com.intellij.openapi.command.WriteCommandAction
import com.intellij.openapi.command.impl.FinishMarkAction
import com.intellij.openapi.command.impl.StartMarkAction
import com.intellij.openapi.editor.Editor
import com.intellij.openapi.editor.RangeMarker
import com.intellij.openapi.editor.event.CaretEvent
import com.intellij.openapi.editor.event.CaretListener
import com.intellij.openapi.editor.ex.util.EditorUtil
import com.intellij.openapi.util.Disposer
import com.intellij.openapi.util.Key
import com.intellij.openapi.util.TextRange
import com.intellij.psi.*
import com.intellij.psi.util.PsiTreeUtil
import com.intellij.refactoring.JavaRefactoringSettings
import com.intellij.refactoring.extractMethod.ExtractMethodDialog
import com.intellij.refactoring.extractMethod.ExtractMethodHandler
import com.intellij.refactoring.extractMethod.newImpl.ExtractSelector
import com.intellij.refactoring.extractMethod.newImpl.MethodExtractor
import com.intellij.refactoring.extractMethod.newImpl.inplace.InplaceExtractUtils.addInlaySettingsElement
import com.intellij.refactoring.extractMethod.newImpl.inplace.InplaceExtractUtils.createChangeBasedDisposable
import com.intellij.refactoring.extractMethod.newImpl.inplace.InplaceExtractUtils.createChangeSignatureGotIt
import com.intellij.refactoring.extractMethod.newImpl.inplace.InplaceExtractUtils.createGreedyRangeMarker
import com.intellij.refactoring.extractMethod.newImpl.inplace.InplaceExtractUtils.createNavigationGotIt
import com.intellij.refactoring.extractMethod.newImpl.inplace.InplaceExtractUtils.createPreview
import com.intellij.refactoring.extractMethod.newImpl.inplace.InplaceExtractUtils.findElementAt
import com.intellij.refactoring.extractMethod.newImpl.inplace.InplaceExtractUtils.showInEditor
import com.intellij.refactoring.rename.inplace.InplaceRefactoring
import com.intellij.refactoring.suggested.range
import com.intellij.refactoring.util.CommonRefactoringUtil
import org.jetbrains.annotations.Nls
class InplaceMethodExtractor(private val editor: Editor,
private val range: TextRange,
private val targetClass: PsiClass,
private val popupProvider: ExtractMethodPopupProvider,
private val initialMethodName: String) {
companion object {
private val INPLACE_METHOD_EXTRACTOR = Key<InplaceMethodExtractor>("InplaceMethodExtractor")
fun getActiveExtractor(editor: Editor): InplaceMethodExtractor? {
return TemplateManagerImpl.getTemplateState(editor)?.properties?.get(INPLACE_METHOD_EXTRACTOR) as? InplaceMethodExtractor
}
private fun setActiveExtractor(editor: Editor, extractor: InplaceMethodExtractor) {
TemplateManagerImpl.getTemplateState(editor)?.properties?.put(INPLACE_METHOD_EXTRACTOR, extractor)
}
}
private val file: PsiFile = targetClass.containingFile
private fun createExtractor(): DuplicatesMethodExtractor {
val elements = ExtractSelector().suggestElementsToExtract(file, range)
val shouldBeStatic = popupProvider.makeStatic ?: false
return DuplicatesMethodExtractor.create(targetClass, elements, initialMethodName, shouldBeStatic)
}
private val extractor: DuplicatesMethodExtractor = createExtractor()
private val editorState = EditorState(editor)
private var methodIdentifierRange: RangeMarker? = null
private var callIdentifierRange: RangeMarker? = null
private val disposable = Disposer.newDisposable()
private val project = file.project
fun extractAndRunTemplate(suggestedNames: LinkedHashSet<String>) {
try {
val startMarkAction = StartMarkAction.start(editor, project, ExtractMethodHandler.getRefactoringName())
Disposer.register(disposable) { FinishMarkAction.finish(project, editor, startMarkAction) }
val elements = ExtractSelector().suggestElementsToExtract(file, range)
MethodExtractor.sendRefactoringStartedEvent(elements.toTypedArray())
val (callElements, method) = extractor.extract()
val callExpression = PsiTreeUtil.findChildOfType(callElements.first(), PsiMethodCallExpression::class.java, false)
?: throw IllegalStateException()
val methodIdentifier = method.nameIdentifier ?: throw IllegalStateException()
val callIdentifier = callExpression.methodExpression.referenceNameElement ?: throw IllegalStateException()
methodIdentifierRange = createGreedyRangeMarker(editor.document, methodIdentifier.textRange)
callIdentifierRange = createGreedyRangeMarker(editor.document, callIdentifier.textRange)
val callRange = TextRange(callElements.first().textRange.startOffset, callElements.last().textRange.endOffset)
val codePreview = createPreview(editor, method.textRange, methodIdentifier.textRange.endOffset, callRange,
callIdentifier.textRange.endOffset)
Disposer.register(disposable, codePreview)
val templateState = ExtractMethodTemplateBuilder(editor, ExtractMethodHandler.getRefactoringName())
.withCompletionNames(suggestedNames.toList())
.withCompletionAdvertisement(InplaceRefactoring.getPopupOptionsAdvertisement())
.enableRestartForHandler(ExtractMethodHandler::class.java)
.onBroken {
editorState.revert()
}
.onSuccess {
val range = callIdentifierRange?.range ?: return@onSuccess
val methodName = editor.document.getText(range)
val extractedMethod = findElementAt<PsiMethod>(file, methodIdentifierRange) ?: return@onSuccess
InplaceExtractMethodCollector.executed.log(initialMethodName != methodName)
installGotItTooltips(editor, callIdentifierRange?.range, methodIdentifierRange?.range)
MethodExtractor.sendRefactoringDoneEvent(extractedMethod)
extractor.replaceDuplicates(editor, extractedMethod)
}
.disposeWithTemplate(disposable)
.withValidation { variableRange ->
val errorMessage = getIdentifierError(file, variableRange)
if (errorMessage != null) {
CommonRefactoringUtil.showErrorHint(project, editor, errorMessage, ExtractMethodHandler.getRefactoringName(), null)
}
errorMessage == null
}
.createTemplate(file, methodIdentifier.textRange, callIdentifier.textRange)
afterTemplateStart(templateState)
} catch (e: Throwable) {
Disposer.dispose(disposable)
throw e
}
}
private fun installGotItTooltips(editor: Editor, navigationGotItRange: TextRange?, changeSignatureGotItRange: TextRange?){
if (navigationGotItRange == null || changeSignatureGotItRange == null) {
return
}
val parentDisposable = Disposer.newDisposable().also { EditorUtil.disposeWithEditor(editor, it) }
val previousBalloonFuture = createNavigationGotIt(parentDisposable)?.showInEditor(editor, navigationGotItRange)
val disposable = createChangeBasedDisposable(editor)
val caretListener = object: CaretListener {
override fun caretPositionChanged(event: CaretEvent) {
if (editor.logicalPositionToOffset(event.newPosition) in changeSignatureGotItRange) {
previousBalloonFuture?.thenAccept { balloon -> balloon.hide(true) }
createChangeSignatureGotIt(parentDisposable)?.showInEditor(editor, changeSignatureGotItRange)
Disposer.dispose(disposable)
}
}
}
editor.caretModel.addCaretListener(caretListener, disposable)
}
private fun afterTemplateStart(templateState: TemplateState) {
setActiveExtractor(editor, this)
popupProvider.setChangeListener {
val shouldAnnotate = popupProvider.annotate
if (shouldAnnotate != null) {
PropertiesComponent.getInstance(project).setValue(ExtractMethodDialog.EXTRACT_METHOD_GENERATE_ANNOTATIONS, shouldAnnotate, true)
}
val makeStatic = popupProvider.makeStatic
if (!popupProvider.staticPassFields && makeStatic != null) {
JavaRefactoringSettings.getInstance().EXTRACT_STATIC_METHOD = makeStatic
}
restartInplace()
}
popupProvider.setShowDialogAction { actionEvent -> restartInDialog(actionEvent == null) }
addInlaySettingsElement(templateState, popupProvider)?.also { inlay ->
Disposer.register(disposable, inlay)
}
}
private fun getIdentifierError(file: PsiFile, variableRange: TextRange): @Nls String? {
val methodName = file.viewProvider.document.getText(variableRange)
val call = PsiTreeUtil.findElementOfClassAtOffset(file, variableRange.startOffset, PsiMethodCallExpression::class.java, false)
return if (! PsiNameHelper.getInstance(project).isIdentifier(methodName)) {
JavaRefactoringBundle.message("extract.method.error.invalid.name")
} else if (call?.resolveMethod() == null) {
JavaRefactoringBundle.message("extract.method.error.method.conflict")
} else {
null
}
}
private fun setMethodName(methodName: String) {
val callRange = callIdentifierRange ?: return
val methodRange = methodIdentifierRange ?: return
if (callRange.isValid && callRange.isValid) {
editor.document.replaceString(callRange.startOffset, callRange.endOffset, methodName)
editor.document.replaceString(methodRange.startOffset, methodRange.endOffset, methodName)
PsiDocumentManager.getInstance(project).commitDocument(editor.document)
}
}
fun restartInDialog(isLinkUsed: Boolean = false) {
val methodRange = callIdentifierRange?.range
val methodName = if (methodRange != null) editor.document.getText(methodRange) else ""
InplaceExtractMethodCollector.openExtractDialog.log(project, isLinkUsed)
TemplateManagerImpl.getTemplateState(editor)?.gotoEnd(true)
val elements = ExtractSelector().suggestElementsToExtract(targetClass.containingFile, range)
extractInDialog(targetClass, elements, methodName, popupProvider.makeStatic ?: extractor.extractOptions.isStatic)
}
private fun restartInplace() {
val identifierRange = callIdentifierRange?.range
val methodName = if (identifierRange != null) editor.document.getText(identifierRange) else null
TemplateManagerImpl.getTemplateState(editor)?.gotoEnd(true)
WriteCommandAction.writeCommandAction(project).withName(ExtractMethodHandler.getRefactoringName()).run<Throwable> {
val inplaceExtractor = InplaceMethodExtractor(editor, range, targetClass, popupProvider, initialMethodName)
inplaceExtractor.extractAndRunTemplate(linkedSetOf())
if (methodName != null) {
inplaceExtractor.setMethodName(methodName)
}
}
}
} | java/java-impl-refactorings/src/com/intellij/refactoring/extractMethod/newImpl/inplace/InplaceMethodExtractor.kt | 597307501 |
package org.stepik.android.view.injection.course
import android.app.Activity
import dagger.assisted.Assisted
import dagger.assisted.AssistedFactory
import org.stepik.android.domain.course.analytic.CourseViewSource
import org.stepik.android.presentation.course.CoursePresenter
import org.stepik.android.presentation.course_purchase.model.CoursePurchaseData
import org.stepik.android.view.course.ui.delegates.CourseHeaderDelegate
@AssistedFactory
interface CourseHeaderDelegateFactory {
fun create(
courseActivity: Activity,
coursePresenter: CoursePresenter,
courseViewSource: CourseViewSource,
@Assisted("isAuthorized")
isAuthorized: Boolean,
@Assisted("mustShowCourseRevenue")
mustShowCourseRevenue: Boolean,
@Assisted("showCourseRevenueAction")
showCourseRevenueAction: () -> Unit,
@Assisted("onSubmissionCountClicked")
onSubmissionCountClicked: () -> Unit,
@Assisted("isLocalSubmissionsEnabled")
isLocalSubmissionsEnabled: Boolean,
@Assisted("showCourseSearchAction")
showCourseSearchAction: () -> Unit,
coursePurchaseFlowAction: (CoursePurchaseData, Boolean) -> Unit
): CourseHeaderDelegate
} | app/src/main/java/org/stepik/android/view/injection/course/CourseHeaderDelegateFactory.kt | 1014765799 |
package com.github.droibit.plugin.rxjava.postfix.templates
import com.github.droibit.plugin.rxjava.postfix.utils.RxJavaClassName.FLOWABLE
import com.github.droibit.plugin.rxjava.postfix.utils.RxJavaPostfixTemplatesUtils.getStaticPrefix
import com.intellij.codeInsight.template.Template
import com.intellij.codeInsight.template.Template.Property.USE_STATIC_IMPORT_IF_POSSIBLE
import com.intellij.codeInsight.template.TemplateManager
import com.intellij.codeInsight.template.postfix.templates.StringBasedPostfixTemplate
import com.intellij.codeInsight.template.postfix.util.JavaPostfixTemplatesUtils.*
import com.intellij.psi.PsiElement
import com.intellij.psi.PsiExpression
class FlowableFromIterableOrArrayTemplate : StringBasedPostfixTemplate(
"ffrom",
"Flowable.fromIterable/Array(expr)",
selectorTopmost(IS_ITERABLE_OR_ARRAY)) {
override fun createTemplate(manager: TemplateManager, templateString: String): Template {
return super.createTemplate(manager, templateString).apply {
isToReformat = shouldReformat()
setValue(USE_STATIC_IMPORT_IF_POSSIBLE, false)
}
}
override fun getTemplateString(element: PsiElement): String? {
if (element !is PsiExpression) {
return null
}
val methodName = if (isArray(element.type)) "fromArray" else "fromIterable"
val fqMethod = getStaticPrefix(FLOWABLE.className, methodName, element)
return "$fqMethod(\$expr\$)\$END\$"
}
} | plugin/src/main/java/com/github/droibit/plugin/rxjava/postfix/templates/FlowableFromIterableOrArrayTemplate.kt | 1988502815 |
package com.glodanif.bluetoothchat.ui.widget
import android.animation.Animator
import android.annotation.SuppressLint
import android.content.Context
import android.graphics.Color
import android.graphics.Rect
import android.graphics.drawable.ColorDrawable
import android.os.Build
import androidx.annotation.ColorInt
import android.view.Gravity
import android.view.View
import android.view.ViewAnimationUtils
import android.view.WindowManager
import android.widget.ImageView
import android.widget.PopupWindow
import android.widget.TextView
import com.amulyakhare.textdrawable.TextDrawable
import com.glodanif.bluetoothchat.R
import com.glodanif.bluetoothchat.ui.util.EmptyAnimatorListener
import com.glodanif.bluetoothchat.utils.getFirstLetter
import com.glodanif.bluetoothchat.utils.getLayoutInflater
class SettingsPopup(context: Context) : PopupWindow() {
enum class Option {
PROFILE,
IMAGES,
SETTINGS,
ABOUT;
}
private val appearingAnimationDuration = 200L
@ColorInt
private var color = Color.GRAY
private var userName = ""
private var clickListener: ((Option) -> (Unit))? = null
private var rootView: View
private var container: View
private var avatar: ImageView
private var userNameLabel: TextView
private var isDismissing: Boolean = false
fun populateData(userName: String, @ColorInt color: Int) {
this.userName = userName
this.color = color
}
fun setOnOptionClickListener(clickListener: (Option) -> (Unit)) {
this.clickListener = clickListener
}
init {
@SuppressLint("InflateParams")
rootView = context.getLayoutInflater().inflate(R.layout.popup_settings, null)
container = rootView.findViewById(R.id.fl_container)
avatar = rootView.findViewById(R.id.iv_avatar)
userNameLabel = rootView.findViewById(R.id.tv_username)
rootView.findViewById<View>(R.id.ll_user_profile_container).setOnClickListener {
dismiss()
clickListener?.invoke(Option.PROFILE)
}
rootView.findViewById<View>(R.id.ll_images_button).setOnClickListener {
dismiss()
clickListener?.invoke(Option.IMAGES)
}
rootView.findViewById<View>(R.id.ll_settings_button).setOnClickListener {
dismiss()
clickListener?.invoke(Option.SETTINGS)
}
rootView.findViewById<View>(R.id.ll_about_button).setOnClickListener {
dismiss()
clickListener?.invoke(Option.ABOUT)
}
contentView = rootView
}
fun show(anchor: View) {
prepare()
populateUi()
val xPosition: Int
val yPosition: Int
val location = IntArray(2)
anchor.getLocationOnScreen(location)
val anchorRect = Rect(location[0], location[1],
location[0] + anchor.width, location[1] + anchor.height)
xPosition = anchorRect.right + rootView.measuredWidth
yPosition = anchorRect.top
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
container.visibility = View.VISIBLE
}
showAtLocation(anchor, Gravity.NO_GRAVITY, xPosition, yPosition)
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
container.post {
if (container.isAttachedToWindow) {
val animator = ViewAnimationUtils.createCircularReveal(container,
container.width, 0, 0f, container.measuredWidth.toFloat())
container.visibility = View.VISIBLE
animator.duration = appearingAnimationDuration
animator.start()
}
}
}
}
override fun dismiss() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP && !isDismissing) {
val animator = ViewAnimationUtils.createCircularReveal(container,
container.width, 0, container.measuredWidth.toFloat(), 0f)
container.visibility = View.VISIBLE
animator.addListener(object : EmptyAnimatorListener() {
override fun onAnimationStart(animation: Animator?) {
isDismissing = true
}
override fun onAnimationEnd(animation: Animator?) {
actualDismiss()
}
})
animator.duration = appearingAnimationDuration
animator.start()
} else {
actualDismiss()
}
}
private fun actualDismiss() {
isDismissing = false
super.dismiss()
}
private fun prepare() {
setBackgroundDrawable(ColorDrawable())
width = WindowManager.LayoutParams.WRAP_CONTENT
height = WindowManager.LayoutParams.WRAP_CONTENT
isTouchable = true
isFocusable = true
isOutsideTouchable = true
}
private fun populateUi() {
val drawable = TextDrawable.builder().buildRound(userName.getFirstLetter(), color)
avatar.setImageDrawable(drawable)
userNameLabel.text = userName
}
}
| app/src/main/kotlin/com/glodanif/bluetoothchat/ui/widget/SettingsPopup.kt | 1697054901 |
package de.langerhans.discord.gitbot
import org.springframework.boot.SpringApplication
import org.springframework.boot.autoconfigure.SpringBootApplication
@SpringBootApplication
open class GitbotApplication {
companion object {
@JvmStatic fun main(args: Array<String>) {
SpringApplication.run(GitbotApplication::class.java, *args)
}
}
}
| src/main/kotlin/de/langerhans/discord/gitbot/GitbotApplication.kt | 3525541324 |
package com.aemtools.lang.htl.psi.mixin
import com.aemtools.lang.htl.psi.HtlPsiBaseElement
import com.aemtools.lang.htl.psi.HtlStringLiteral
import com.aemtools.lang.htl.psi.visitor.HtlElementVisitor
import com.intellij.lang.ASTNode
import com.intellij.psi.PsiElement
import com.intellij.psi.PsiElementVisitor
import com.intellij.psi.PsiNamedElement
/**
* @author Dmytro_Troynikov
*/
abstract class HtlStringLiteralMixin(node: ASTNode)
: HtlPsiBaseElement(node), HtlStringLiteral, PsiNamedElement {
override fun accept(visitor: PsiElementVisitor) {
if (visitor is HtlElementVisitor) {
return visitor.visitString(this)
} else {
super.accept(visitor)
}
}
override fun setName(name: String): PsiElement {
return this
}
override fun getName(): String {
return if (this.text.length <= 2) {
return ""
} else {
this.text.substring(1, this.text.length - 1)
}
}
}
| lang/src/main/kotlin/com/aemtools/lang/htl/psi/mixin/HtlStringLiteralMixin.kt | 62700527 |
// Copyright 2000-2021 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.
package com.intellij.workspaceModel.ide.impl.legacyBridge.watcher
import com.intellij.openapi.project.Project
import com.intellij.openapi.util.io.FileUtil
import com.intellij.workspaceModel.ide.JpsFileEntitySource
import com.intellij.workspaceModel.ide.WorkspaceModel
import com.intellij.workspaceModel.ide.getInstance
import com.intellij.workspaceModel.storage.*
import com.intellij.workspaceModel.storage.bridgeEntities.*
import com.intellij.workspaceModel.storage.url.VirtualFileUrl
import com.intellij.workspaceModel.storage.url.VirtualFileUrlManager
import kotlin.reflect.KClass
open class VirtualFileUrlWatcher(val project: Project) {
private val virtualFileManager = VirtualFileUrlManager.getInstance(project)
internal var isInsideFilePointersUpdate = false
private set
private val pointers = listOf(
// Library roots
LibraryRootFileWatcher(),
// Library excluded roots
EntityVirtualFileUrlWatcher(
LibraryEntity::class, ModifiableLibraryEntity::class,
propertyName = LibraryEntity::excludedRoots.name,
modificator = { oldVirtualFileUrl, newVirtualFileUrl ->
excludedRoots = excludedRoots - oldVirtualFileUrl
excludedRoots = excludedRoots + newVirtualFileUrl
}
),
// Content root urls
EntityVirtualFileUrlWatcher(
ContentRootEntity::class, ModifiableContentRootEntity::class,
propertyName = ContentRootEntity::url.name,
modificator = { _, newVirtualFileUrl -> url = newVirtualFileUrl }
),
// Content root excluded urls
EntityVirtualFileUrlWatcher(
ContentRootEntity::class, ModifiableContentRootEntity::class,
propertyName = ContentRootEntity::excludedUrls.name,
modificator = { oldVirtualFileUrl, newVirtualFileUrl ->
excludedUrls = excludedUrls - oldVirtualFileUrl
excludedUrls = excludedUrls + newVirtualFileUrl
}
),
// Source roots
EntityVirtualFileUrlWatcher(
SourceRootEntity::class, ModifiableSourceRootEntity::class,
propertyName = SourceRootEntity::url.name,
modificator = { _, newVirtualFileUrl -> url = newVirtualFileUrl }
),
// Java module settings entity compiler output
EntityVirtualFileUrlWatcher(
JavaModuleSettingsEntity::class, ModifiableJavaModuleSettingsEntity::class,
propertyName = JavaModuleSettingsEntity::compilerOutput.name,
modificator = { _, newVirtualFileUrl -> compilerOutput = newVirtualFileUrl }
),
// Java module settings entity compiler output for tests
EntityVirtualFileUrlWatcher(
JavaModuleSettingsEntity::class, ModifiableJavaModuleSettingsEntity::class,
propertyName = JavaModuleSettingsEntity::compilerOutputForTests.name,
modificator = { _, newVirtualFileUrl -> compilerOutputForTests = newVirtualFileUrl }
),
EntitySourceFileWatcher(JpsFileEntitySource.ExactFile::class, { it.file.url }, { source, file -> source.copy(file = file) }),
EntitySourceFileWatcher(JpsFileEntitySource.FileInDirectory::class, { it.directory.url },
{ source, file -> source.copy(directory = file) })
)
fun onVfsChange(oldUrl: String, newUrl: String) {
try {
isInsideFilePointersUpdate = true
val entityWithVirtualFileUrl = mutableListOf<EntityWithVirtualFileUrl>()
WorkspaceModel.getInstance(project).updateProjectModel { diff ->
val oldFileUrl = virtualFileManager.fromUrl(oldUrl)
calculateAffectedEntities(diff, oldFileUrl, entityWithVirtualFileUrl)
oldFileUrl.subTreeFileUrls.map { fileUrl -> calculateAffectedEntities(diff, fileUrl, entityWithVirtualFileUrl) }
val result = entityWithVirtualFileUrl.filter { shouldUpdateThisEntity(it.entity) }.toList()
pointers.forEach { it.onVfsChange(oldUrl, newUrl, result, virtualFileManager, diff) }
}
}
finally {
isInsideFilePointersUpdate = false
}
}
// A workaround to have an opportunity to skip some entities from being updated (for now it's only for Rider to avoid update ContentRoots)
open fun shouldUpdateThisEntity(entity: WorkspaceEntity): Boolean {
return true
}
companion object {
@JvmStatic
fun getInstance(project: Project): VirtualFileUrlWatcher = project.getComponent(VirtualFileUrlWatcher::class.java)
internal fun calculateAffectedEntities(storage: WorkspaceEntityStorage, virtualFileUrl: VirtualFileUrl,
aggregator: MutableList<EntityWithVirtualFileUrl>) {
storage.getVirtualFileUrlIndex().findEntitiesByUrl(virtualFileUrl).forEach {
aggregator.add(EntityWithVirtualFileUrl(it.first, virtualFileUrl, it.second))
}
}
}
}
data class EntityWithVirtualFileUrl(val entity: WorkspaceEntity, val virtualFileUrl: VirtualFileUrl, val propertyName: String)
private interface LegacyFileWatcher {
fun onVfsChange(oldUrl: String, newUrl: String, entitiesWithVFU: List<EntityWithVirtualFileUrl>, virtualFileManager: VirtualFileUrlManager,
diff: WorkspaceEntityStorageBuilder)
}
private class EntitySourceFileWatcher<T : EntitySource>(
val entitySource: KClass<T>,
val containerToUrl: (T) -> String,
val createNewSource: (T, VirtualFileUrl) -> T
) : LegacyFileWatcher {
override fun onVfsChange(oldUrl: String, newUrl: String, entitiesWithVFU: List<EntityWithVirtualFileUrl>, virtualFileManager: VirtualFileUrlManager,
diff: WorkspaceEntityStorageBuilder) {
val entities = diff.entitiesBySource { it::class == entitySource }
for ((entitySource, mapOfEntities) in entities) {
@Suppress("UNCHECKED_CAST")
val urlFromContainer = containerToUrl(entitySource as T)
if (!FileUtil.startsWith(urlFromContainer, oldUrl)) continue
val newVfurl = virtualFileManager.fromUrl(newUrl + urlFromContainer.substring(oldUrl.length))
val newEntitySource = createNewSource(entitySource, newVfurl)
mapOfEntities.values.flatten().forEach { diff.changeSource(it, newEntitySource) }
}
}
}
/**
* Legacy file pointer that can track and update urls stored in a [WorkspaceEntity].
* [entityClass] - class of a [WorkspaceEntity] that contains an url being tracked
* [modifiableEntityClass] - class of modifiable entity of [entityClass]
* [propertyName] - name of the field which contains [VirtualFileUrl]
* [modificator] - function for modifying an entity
* There 2 functions are created for better convenience. You should use only one from them.
*/
private class EntityVirtualFileUrlWatcher<E : WorkspaceEntity, M : ModifiableWorkspaceEntity<E>>(
val entityClass: KClass<E>,
val modifiableEntityClass: KClass<M>,
val propertyName: String,
val modificator: M.(VirtualFileUrl, VirtualFileUrl) -> Unit
) : LegacyFileWatcher {
override fun onVfsChange(oldUrl: String, newUrl: String, entitiesWithVFU: List<EntityWithVirtualFileUrl>, virtualFileManager: VirtualFileUrlManager,
diff: WorkspaceEntityStorageBuilder) {
entitiesWithVFU.filter { entityClass.isInstance(it.entity) && it.propertyName == propertyName }.forEach { entityWithVFU ->
val existingVirtualFileUrl = entityWithVFU.virtualFileUrl
val savedUrl = existingVirtualFileUrl.url
val newTrackedUrl = newUrl + savedUrl.substring(oldUrl.length)
val newContainer = virtualFileManager.fromUrl(newTrackedUrl)
@Suppress("UNCHECKED_CAST")
entityWithVFU.entity as E
diff.modifyEntity(modifiableEntityClass.java, entityWithVFU.entity) {
this.modificator(existingVirtualFileUrl, newContainer)
}
}
}
}
/**
* It's responsible for updating complex case than [VirtualFileUrl] contains not in the entity itself but in internal data class.
* This is about LibraryEntity -> roots (LibraryRoot) -> url (VirtualFileUrl).
*/
private class LibraryRootFileWatcher: LegacyFileWatcher {
private val propertyName = LibraryEntity::roots.name
override fun onVfsChange(oldUrl: String, newUrl: String, entitiesWithVFU: List<EntityWithVirtualFileUrl>, virtualFileManager: VirtualFileUrlManager,
diff: WorkspaceEntityStorageBuilder) {
entitiesWithVFU.filter { LibraryEntity::class.isInstance(it.entity) && it.propertyName == propertyName }.forEach { entityWithVFU ->
val oldVFU = entityWithVFU.virtualFileUrl
val newVFU = virtualFileManager.fromUrl(newUrl + oldVFU.url.substring(oldUrl.length))
entityWithVFU.entity as LibraryEntity
val oldLibraryRoots = diff.resolve(entityWithVFU.entity.persistentId())?.roots?.filter { it.url == oldVFU }
?: error("Incorrect state of the VFU index")
oldLibraryRoots.forEach { oldLibraryRoot ->
val newLibraryRoot = LibraryRoot(newVFU, oldLibraryRoot.type, oldLibraryRoot.inclusionOptions)
diff.modifyEntity(ModifiableLibraryEntity::class.java, entityWithVFU.entity) {
roots = roots - oldLibraryRoot
roots = roots + newLibraryRoot
}
}
}
}
} | platform/lang-impl/src/com/intellij/workspaceModel/ide/impl/legacyBridge/watcher/VirtualFileUrlWatcher.kt | 3973155306 |
package tests.coding
import io.fluidsonic.json.*
import kotlin.test.*
class AbstractJsonEncoderCodecTest {
@Test
fun testDecoderCodecForClassReturnsNested() {
expect(OuterEncoderCodec.decoderCodecForType<Unit, JsonCodingContext>()).toBe(InnerDecoderCodec)
}
private object InnerDecoderCodec : AbstractJsonDecoderCodec<Unit, JsonCodingContext>() {
override fun JsonDecoder<JsonCodingContext>.decode(valueType: JsonCodingType<Unit>) =
Unit
}
private object OuterEncoderCodec : AbstractJsonEncoderCodec<String, JsonCodingContext>(
additionalProviders = listOf(InnerDecoderCodec)
) {
override fun JsonEncoder<JsonCodingContext>.encode(value: String) {}
}
}
| coding/tests-jvm/AbstractJsonEncoderCodecTest.kt | 2079200865 |
// Copyright 2000-2021 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.
package org.jetbrains.plugins.github.pullrequest.ui.changes
import com.intellij.openapi.actionSystem.ActionGroup
import com.intellij.openapi.actionSystem.ActionManager
import com.intellij.openapi.actionSystem.DefaultActionGroup
import com.intellij.openapi.actionSystem.IdeActions
import com.intellij.openapi.project.Project
import com.intellij.openapi.vcs.changes.Change
import com.intellij.openapi.vcs.changes.ui.ChangesTree
import com.intellij.openapi.vcs.changes.ui.TreeActionsToolbarPanel
import com.intellij.openapi.vcs.changes.ui.TreeModelBuilder
import com.intellij.openapi.vcs.changes.ui.VcsTreeModelData
import com.intellij.ui.ExpandableItemsHandler
import com.intellij.ui.SelectionSaver
import com.intellij.util.ui.UIUtil
import com.intellij.util.ui.tree.TreeUtil
import org.jetbrains.plugins.github.ui.util.SingleValueModel
import java.awt.event.FocusAdapter
import java.awt.event.FocusEvent
import javax.swing.JComponent
internal class GHPRChangesTreeFactory(private val project: Project,
private val changesModel: SingleValueModel<out Collection<Change>>) {
fun create(emptyTextText: String): ChangesTree {
val tree = object : ChangesTree(project, false, false) {
override fun rebuildTree() {
updateTreeModel(TreeModelBuilder(project, grouping).setChanges(changesModel.value, null).build())
if (isSelectionEmpty && !isEmpty) TreeUtil.selectFirstNode(this)
}
override fun getData(dataId: String) = super.getData(dataId) ?: VcsTreeModelData.getData(project, this, dataId)
}.apply {
emptyText.text = emptyTextText
}.also {
UIUtil.putClientProperty(it, ExpandableItemsHandler.IGNORE_ITEM_SELECTION, true)
SelectionSaver.installOn(it)
it.addFocusListener(object : FocusAdapter() {
override fun focusGained(e: FocusEvent?) {
if (it.isSelectionEmpty && !it.isEmpty) TreeUtil.selectFirstNode(it)
}
})
}
changesModel.addAndInvokeValueChangedListener(tree::rebuildTree)
return tree
}
companion object {
fun createTreeToolbar(actionManager: ActionManager, treeContainer: JComponent): JComponent {
val changesToolbarActionGroup = actionManager.getAction("Github.PullRequest.Changes.Toolbar") as ActionGroup
val changesToolbar = actionManager.createActionToolbar("ChangesBrowser", changesToolbarActionGroup, true)
val treeActionsGroup = DefaultActionGroup(actionManager.getAction(IdeActions.ACTION_EXPAND_ALL),
actionManager.getAction(IdeActions.ACTION_COLLAPSE_ALL))
return TreeActionsToolbarPanel(changesToolbar, treeActionsGroup, treeContainer)
}
}
} | plugins/github/src/org/jetbrains/plugins/github/pullrequest/ui/changes/GHPRChangesTreeFactory.kt | 4151558259 |
/*
* Copyright 2018 New Vector Ltd
*
* 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.matrix.androidsdk.crypto.util
import org.junit.Assert
import org.junit.FixMethodOrder
import org.junit.Test
import org.junit.runners.MethodSorters
@FixMethodOrder(MethodSorters.JVM)
class Base58Test {
@Test
fun encode() {
// Example comes from https://github.com/keis/base58
Assert.assertEquals("StV1DL6CwTryKyV", base58encode("hello world".toByteArray()))
}
@Test
fun decode() {
// Example comes from https://github.com/keis/base58
Assert.assertArrayEquals("hello world".toByteArray(), base58decode("StV1DL6CwTryKyV"));
}
@Test
fun encode_curve25519() {
// Encode a 32 bytes key
Assert.assertEquals("4F85ZySpwyY6FuH7mQYyyr5b8nV9zFRBLj92AJa37sMr",
base58encode(("0123456789" + "0123456789" + "0123456789" + "01").toByteArray()))
}
@Test
fun decode_curve25519() {
Assert.assertArrayEquals(("0123456789" + "0123456789" + "0123456789" + "01").toByteArray(),
base58decode("4F85ZySpwyY6FuH7mQYyyr5b8nV9zFRBLj92AJa37sMr"))
}
} | matrix-sdk-crypto/src/test/java/org/matrix/androidsdk/crypto/util/Base58Test.kt | 1132063123 |
package org.mrlem.happycows.ui.caches
import com.badlogic.gdx.Gdx
import com.badlogic.gdx.audio.Music
/**
* @author Sébastien Guillemin <[email protected]>
*/
class MusicCache : AbstractCache<String, Music>() {
override fun newResource(key: String): Music = Gdx.audio.newMusic(Gdx.files.internal(key))
companion object {
const val SCOTLAND_MUSIC_ID = "mfx/scotland_the_brave.ogg"
var instance = MusicCache()
}
}
| core/src/org/mrlem/happycows/ui/caches/MusicCache.kt | 1824887167 |
package be.renaudraas.kotlinplayground
import android.support.test.InstrumentationRegistry
import android.support.test.runner.AndroidJUnit4
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.Assert.*
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getTargetContext()
assertEquals("be.renaudraas.kotlinplayground", appContext.packageName)
}
}
| app/src/androidTest/java/be/renaudraas/kotlinplayground/ExampleInstrumentedTest.kt | 3991562983 |
// Copyright 2000-2019 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.
package com.intellij.codeInsight.hints.presentation
import com.intellij.openapi.editor.markup.TextAttributes
import java.awt.Color
import java.awt.Graphics2D
/**
* Adds background color.
*/
class BackgroundPresentation(
presentation: InlayPresentation,
var color: Color? = null
) : StaticDelegatePresentation(presentation) {
override fun paint(g: Graphics2D, attributes: TextAttributes) {
val backgroundColor = color ?: attributes.backgroundColor
val oldColor = g.color
if (backgroundColor != null) {
g.color = backgroundColor
g.fillRect(0, 0, width, height)
}
try {
presentation.paint(g, attributes)
} finally {
g.color = oldColor
}
}
} | platform/lang-impl/src/com/intellij/codeInsight/hints/presentation/BackgroundPresentation.kt | 1416634227 |
/*
* WiFiAnalyzer
* Copyright (C) 2015 - 2022 VREM Software Development <[email protected]>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>
*/
package com.vrem.wifianalyzer.wifi.accesspoint
import com.vrem.wifianalyzer.R
import org.junit.Assert.*
import org.junit.Test
class ConnectionViewTypeTest {
@Test
fun testConnectionViewTypeCount() {
assertEquals(3, ConnectionViewType.values().size)
}
@Test
fun testGetLayout() {
assertEquals(R.layout.access_point_view_complete, ConnectionViewType.COMPLETE.layout)
assertEquals(R.layout.access_point_view_compact, ConnectionViewType.COMPACT.layout)
assertEquals(R.layout.access_point_view_hide, ConnectionViewType.HIDE.layout)
}
@Test
fun testIsHide() {
assertFalse(ConnectionViewType.COMPLETE.hide)
assertFalse(ConnectionViewType.COMPACT.hide)
assertTrue(ConnectionViewType.HIDE.hide)
}
} | app/src/test/kotlin/com/vrem/wifianalyzer/wifi/accesspoint/ConnectionViewTypeTest.kt | 2938945763 |
Subsets and Splits