{"signature":"abstract fun Canvas . drawDetection ( detection : T )","body":"abstract fun Canvas . drawDetection ( detection : T )","docstring":"/**\n * Draw given detection result on the [Canvas].\n */"} {"signature":"open fun onDetectionSet ( detection : T ? )","body":"= Unit","docstring":"/**\n * Called when a new detection result is set.\n */"} {"signature":"fun setDetection ( detection : T ? )","body":"{ synchronized ( this ) { _detection = detection onDetectionSet ( detection ) postInvalidate ( ) } }","docstring":"/**\n * Set current detection result or null if nothing was detected.\n */"} {"signature":"protected open fun getDeclarationOriginFor ( file : KtFile ) : FirDeclarationOrigin","body":"{ val virtualFile = file . virtualFile return if ( virtualFile . extension == BuiltInSerializerProtocol . BUILTINS_FILE_EXTENSION ) { FirDeclarationOrigin . BuiltIns } else { FirDeclarationOrigin . Library } }","docstring":"/**\n * Computes the origin for the declarations coming from [file].\n *\n * We assume that a stub Kotlin declaration might come only from Library or from BuiltIns.\n * We do the decision based upon the extension of the [file].\n *\n * This method is left open so the inheritors can provide more optimal/strict implementations.\n */"} {"signature":"fun usage ( )","body":"{ }","docstring":"/**\n * [one.two.ext]\n * [one.two.ext]\n *\n * [Foo.ext]\n * [one.two.Foo.ext]\n *\n * [one.two.Foo.ext]\n * [one.two.Foo.ext]\n */"} {"signature":"@ HtmlTagMarker inline fun DATALIST . option ( classes : String ? = null , crossinline block : OPTION . ( ) -> Unit = { } ) : Unit","body":"= OPTION ( attributesMapOf ( \"\" , classes ) , consumer ) . visit ( block )","docstring":"/**\n * Selectable choice\n */"} {"signature":"@ HtmlTagMarker fun DATALIST . option ( classes : String ? = null , content : String = \"\" ) : Unit","body":"= OPTION ( attributesMapOf ( \"\" , classes ) , consumer ) . visit ( { + content } )","docstring":"/**\n * Selectable choice\n */"} {"signature":"@ HtmlTagMarker inline fun DETAILS . legend ( classes : String ? = null , crossinline block : LEGEND . ( ) -> Unit = { } ) : Unit","body":"= LEGEND ( attributesMapOf ( \"\" , classes ) , consumer ) . visit ( block )","docstring":"/**\n * Fieldset legend\n */"} {"signature":"@ HtmlTagMarker inline fun DL . dd ( classes : String ? = null , crossinline block : DD . ( ) -> Unit = { } ) : Unit","body":"= DD ( attributesMapOf ( \"\" , classes ) , consumer ) . visit ( block )","docstring":"/**\n * Definition description\n */"} {"signature":"@ HtmlTagMarker inline fun DL . dt ( classes : String ? = null , crossinline block : DT . ( ) -> Unit = { } ) : Unit","body":"= DT ( attributesMapOf ( \"\" , classes ) , consumer ) . visit ( block )","docstring":"/**\n * Definition term\n */"} {"signature":"fun additionalTraining ( )","body":"{ val ( train , test ) = fashionMnist ( ) val jsonConfigFile = getJSONConfigFile ( ) val model = Sequential . loadModelConfiguration ( jsonConfigFile ) model . use { it . compile ( optimizer = Adam ( ) , loss = Losses . SOFT_MAX_CROSS_ENTROPY_WITH_LOGITS , metric = Metrics . ACCURACY ) it . logSummary ( ) val hdfFile = getWeightsFile ( ) it . loadWeights ( hdfFile ) val accuracyBefore = it . evaluate ( dataset = test , batchSize = ) . metrics [ Metrics . ACCURACY ] println ( \"\" ) it . fit ( dataset = train , validationRate = , epochs = , trainBatchSize = , validationBatchSize = ) val accuracyAfterTraining = it . evaluate ( dataset = test , batchSize = ) . metrics [ Metrics . ACCURACY ] println ( \"\" ) } }","docstring":"/**\n * This example demonstrates the transfer learning concept:\n * - Weights are loaded from .h5 file, configuration is loaded from .json file.\n * - All model weights are not frozen, and can be changed during the training.\n * - No new layers are added.\n *\n * NOTE: Model and weights are resources in `examples` module.\n */"} {"signature":"fun main ( ) : Unit","body":"= additionalTraining ( )","docstring":"/** */"} {"signature":"actual fun < T > CoroutineScope . asyncWithDealy ( delay : Long , block : suspend ( ) -> T ) : Deferred < T >","body":"{ TODO ( \"\" ) }","docstring":"/**\n * JS actual implementation for `asyncWithDelay`\n */"} {"signature":"public fun extractImages ( archivePath : String ) : Array < FloatArray >","body":"{ val archiveStream = DataInputStream ( GZIPInputStream ( FileInputStream ( archivePath ) ) ) val magic = archiveStream . readInt ( ) require ( IMAGE_ARCHIVE_MAGIC == magic ) { \"\" } val imageCount = archiveStream . readInt ( ) val imageRows = archiveStream . readInt ( ) val imageCols = archiveStream . readInt ( ) println ( String . format ( \"\" , imageCount , imageRows , imageCols , archivePath ) ) val imageBuffer = ByteArray ( imageRows * imageCols ) val images = Array ( imageCount ) { archiveStream . readFully ( imageBuffer ) toNormalizedVector ( imageBuffer ) } return images }","docstring":"/**\n * Extracts (Fashion) Mnist images from [archivePath].\n */"} {"signature":"public fun extractLabels ( archivePath : String ) : FloatArray","body":"{ val archiveStream = DataInputStream ( GZIPInputStream ( FileInputStream ( archivePath ) ) ) val magic = archiveStream . readInt ( ) require ( LABEL_ARCHIVE_MAGIC == magic ) { \"\" } val labelCount = archiveStream . readInt ( ) println ( String . format ( \"\" , labelCount , archivePath ) ) val labelBuffer = ByteArray ( labelCount ) archiveStream . readFully ( labelBuffer ) val floats = FloatArray ( labelCount ) for ( i in until labelCount ) { floats [ i ] = OnHeapDataset . convertByteToFloat ( labelBuffer [ i ] ) } return floats }","docstring":"/**\n * Extracts (Fashion) Mnist labels from [archivePath] with number of classes [numClasses].\n */"} {"signature":"fun main ( ) : Unit","body":"= vgg11OnCifar10ExportImport ( )","docstring":"/** */"} {"signature":"fun < T > List < T > . allPairs ( skipSamePairs : Boolean = true ) : Sequence < Pair < T , T > >","body":"= PairsSequence ( this , skipSamePairs )","docstring":"/**\n * Returns a sequence that consists of all possible pair of original list elements, does nothing with potential duplicates\n * @param skipSamePairs indicates whether it should produce pairs from the same element at both first and second positions\n */"} {"signature":"public fun AnyCol . toArrowField ( mismatchSubscriber : ( ConvertingMismatch ) -> Unit = ignoreMismatchMessage ) : Field","body":"{ val column = this val columnType = column . type ( ) val nullable = columnType . isMarkedNullable return when { columnType . isSubtypeOf ( typeOf < String ? > ( ) ) -> Field ( column . name ( ) , FieldType ( nullable , ArrowType . Utf8 ( ) , null ) , emptyList ( ) ) columnType . isSubtypeOf ( typeOf < Boolean ? > ( ) ) -> Field ( column . name ( ) , FieldType ( nullable , ArrowType . Bool ( ) , null ) , emptyList ( ) ) columnType . isSubtypeOf ( typeOf < Byte ? > ( ) ) -> Field ( column . name ( ) , FieldType ( nullable , ArrowType . Int ( , true ) , null ) , emptyList ( ) ) columnType . isSubtypeOf ( typeOf < Short ? > ( ) ) -> Field ( column . name ( ) , FieldType ( nullable , ArrowType . Int ( , true ) , null ) , emptyList ( ) ) columnType . isSubtypeOf ( typeOf < Int ? > ( ) ) -> Field ( column . name ( ) , FieldType ( nullable , ArrowType . Int ( , true ) , null ) , emptyList ( ) ) columnType . isSubtypeOf ( typeOf < Long ? > ( ) ) -> Field ( column . name ( ) , FieldType ( nullable , ArrowType . Int ( , true ) , null ) , emptyList ( ) ) columnType . isSubtypeOf ( typeOf < Float ? > ( ) ) -> Field ( column . name ( ) , FieldType ( nullable , ArrowType . FloatingPoint ( FloatingPointPrecision . SINGLE ) , null ) , emptyList ( ) ) columnType . isSubtypeOf ( typeOf < Double ? > ( ) ) -> Field ( column . name ( ) , FieldType ( nullable , ArrowType . FloatingPoint ( FloatingPointPrecision . DOUBLE ) , null ) , emptyList ( ) ) columnType . isSubtypeOf ( typeOf < LocalDate ? > ( ) ) || columnType . isSubtypeOf ( typeOf < kotlinx . datetime . LocalDate ? > ( ) ) -> Field ( column . name ( ) , FieldType ( nullable , ArrowType . Date ( DateUnit . DAY ) , null ) , emptyList ( ) ) columnType . isSubtypeOf ( typeOf < LocalDateTime ? > ( ) ) || columnType . isSubtypeOf ( typeOf < kotlinx . datetime . LocalDateTime ? > ( ) ) -> Field ( column . name ( ) , FieldType ( nullable , ArrowType . Date ( DateUnit . MILLISECOND ) , null ) , emptyList ( ) ) columnType . isSubtypeOf ( typeOf < LocalTime ? > ( ) ) -> Field ( column . name ( ) , FieldType ( nullable , ArrowType . Time ( TimeUnit . NANOSECOND , ) , null ) , emptyList ( ) ) else -> { mismatchSubscriber ( ConvertingMismatch . SavedAsString ( column . name ( ) , column . typeClass . java ) ) Field ( column . name ( ) , FieldType ( true , ArrowType . Utf8 ( ) , null ) , emptyList ( ) ) } } }","docstring":"/**\n * Create Arrow [Field] (note: this is part of [Schema], does not contain data itself) that has the same\n * name, type and nullable as [this]\n */"} {"signature":"public fun List < AnyCol > . toArrowSchema ( mismatchSubscriber : ( ConvertingMismatch ) -> Unit = ignoreMismatchMessage ) : Schema","body":"{ val fields = this . map { it . toArrowField ( mismatchSubscriber ) } return Schema ( fields ) }","docstring":"/**\n * Create Arrow [Schema] matching [this] actual data.\n * Columns with not supported types will be interpreted as String\n */"} {"signature":"fun lenetOnMnistExportImportToJSONWithAdamOptimizerState ( )","body":"{ val ( train , test ) = mnist ( ) val ( newTrain , validation ) = train . split ( ) val optimizer = Adam ( ) lenet5 ( ) . use { it . compile ( optimizer = optimizer , loss = Losses . SOFT_MAX_CROSS_ENTROPY_WITH_LOGITS , metric = Metrics . ACCURACY ) it . logSummary ( ) print ( it . kGraph ( ) ) it . fit ( trainingDataset = newTrain , validationDataset = validation , epochs = EPOCHS , trainBatchSize = TRAINING_BATCH_SIZE , validationBatchSize = TEST_BATCH_SIZE ) it . save ( modelDirectory = File ( PATH_TO_MODEL ) , saveOptimizerState = true , savingFormat = SavingFormat . JsonConfigCustomVariables ( ) , writingMode = WritingMode . OVERRIDE ) val accuracy = it . evaluate ( dataset = test , batchSize = TEST_BATCH_SIZE ) . metrics [ Metrics . ACCURACY ] println ( \"\" ) } val model = Sequential . loadModelConfiguration ( File ( \"\" ) ) model . use { it . layers . filterIsInstance < Conv2D > ( ) . forEach ( Layer :: freeze ) it . compile ( optimizer = optimizer , loss = Losses . SOFT_MAX_CROSS_ENTROPY_WITH_LOGITS , metric = Metrics . ACCURACY ) it . logSummary ( ) print ( it . kGraph ( ) ) it . loadWeights ( File ( PATH_TO_MODEL ) , loadOptimizerState = true ) val accuracyBefore = it . evaluate ( dataset = test , batchSize = ) . metrics [ Metrics . ACCURACY ] println ( \"\" ) it . fit ( dataset = train , validationRate = , epochs = , trainBatchSize = , validationBatchSize = ) val accuracyAfterTraining = it . evaluate ( dataset = test , batchSize = ) . metrics [ Metrics . ACCURACY ] println ( \"\" ) } val model2 = Sequential . loadModelConfiguration ( File ( \"\" ) ) model2 . use { it . compile ( optimizer = optimizer , loss = Losses . SOFT_MAX_CROSS_ENTROPY_WITH_LOGITS , metric = Metrics . ACCURACY ) it . logSummary ( ) it . loadWeights ( File ( PATH_TO_MODEL ) , loadOptimizerState = false ) val accuracyBefore = it . evaluate ( dataset = test , batchSize = ) . metrics [ Metrics . ACCURACY ] println ( \"\" ) it . fit ( dataset = train , validationRate = , epochs = , trainBatchSize = , validationBatchSize = ) val accuracyAfterTraining = it . evaluate ( dataset = test , batchSize = ) . metrics [ Metrics . ACCURACY ] println ( \"\" ) } }","docstring":"/**\n * This examples demonstrates model, model weights, and optimizer weights export and import back:\n * - Model is exported in Keras-style JSON format; weights are exported in custom (txt) format.\n * - Model is trained on Mnist dataset.\n * - It saves all the data to the project root directory.\n * - The first [Sequential] model is created via JSON configuration, weights, and optimizer state loading.\n * - After loading model is trained again with the same optimizer with frozen Conv2D layers. Only weights in Dense layers can be updated.\n * - The second [Sequential] model is created via JSON configuration and weights loading.\n * - After loading model is trained again with the same optimizer with frozen Conv2D layers. Only weights in Dense layers can be updated.\n * - Results of two training (with restored optimizer state and without) could be compared via accuracy comparison.\n */"} {"signature":"fun main ( ) : Unit","body":"= lenetOnMnistExportImportToJSONWithAdamOptimizerState ( )","docstring":"/** */"} {"signature":"public actual fun < T > setOf ( element : T ) : Set < T >","body":"= java . util . Collections . singleton ( element )","docstring":"/**\n * Returns a new read-only set containing only the specified object [element].\n *\n * The returned set is serializable.\n *\n * @sample samples.collections.Collections.Sets.singletonReadOnlySet\n */"} {"signature":"public fun < T > sortedSetOf ( vararg elements : T ) : java . util . TreeSet < T >","body":"= elements . toCollection ( java . util . TreeSet < T > ( ) )","docstring":"/**\n * Returns a new [java.util.SortedSet] with the given elements.\n */"} {"signature":"public fun < T > sortedSetOf ( comparator : Comparator < in T > , vararg elements : T ) : java . util . TreeSet < T >","body":"= elements . toCollection ( java . util . TreeSet < T > ( comparator ) )","docstring":"/**\n * Returns a new [java.util.SortedSet] with the given [comparator] and elements.\n */"} {"signature":"fun < T : Number > sin ( x : KtNDArray < T > ) : KtNDArray < Double >","body":"= callFunc ( nameMethod = arrayOf ( \"\" ) , args = arrayOf ( x ) , dtype = Double :: class )","docstring":"/**\n * Trigonometric sine, element-wise.\n */"} {"signature":"fun < T : Number > cos ( x : KtNDArray < T > ) : KtNDArray < Double >","body":"= callFunc ( nameMethod = arrayOf ( \"\" ) , args = arrayOf ( x ) , dtype = Double :: class )","docstring":"/**\n * Cosine element-wise.\n */"} {"signature":"fun < T : Number > tan ( x : KtNDArray < T > ) : KtNDArray < Double >","body":"= callFunc ( nameMethod = arrayOf ( \"\" ) , args = arrayOf ( x ) , dtype = Double :: class )","docstring":"/**\n * Compute tangent element-wise.\n */"} {"signature":"fun < T : Number > arcsin ( x : KtNDArray < T > ) : KtNDArray < Double >","body":"= callFunc ( nameMethod = arrayOf ( \"\" ) , args = arrayOf ( x ) , dtype = Double :: class )","docstring":"/**\n * Inverse sine, element-wise.\n */"} {"signature":"fun < T : Number > arccos ( x : KtNDArray < T > ) : KtNDArray < Double >","body":"= callFunc ( nameMethod = arrayOf ( \"\" ) , args = arrayOf ( x ) , dtype = Double :: class )","docstring":"/**\n * Trigonometric inverse cosine, element-wise.\n */"} {"signature":"fun < T : Number > arctan ( x : KtNDArray < T > ) : KtNDArray < Double >","body":"= callFunc ( nameMethod = arrayOf ( \"\" ) , args = arrayOf ( x ) , dtype = Double :: class )","docstring":"/**\n * Trigonometric inverse tangent, element-wise.\n */"} {"signature":"fun < T : Number , E : Number > arctan2 ( x1 : KtNDArray < T > , x2 : KtNDArray < E > ) : KtNDArray < Double >","body":"= callFunc ( nameMethod = arrayOf ( \"\" ) , args = arrayOf ( x1 , x2 ) , dtype = Double :: class )","docstring":"/**\n * Element-wise arc tangent of x1/x2 choosing the quadrant correctly.\n */"} {"signature":"fun < T : Number > degrees ( x : KtNDArray < T > ) : KtNDArray < Double >","body":"= callFunc ( nameMethod = arrayOf ( \"\" ) , args = arrayOf ( x ) , dtype = Double :: class )","docstring":"/**\n * Convert angles from radians to degrees.\n */"} {"signature":"fun < T : Number > radians ( x : KtNDArray < T > ) : KtNDArray < Double >","body":"= callFunc ( nameMethod = arrayOf ( \"\" ) , args = arrayOf ( x ) , dtype = Double :: class )","docstring":"/**\n * Convert angles from degrees to radians.\n */"} {"signature":"fun < T : Number > unwrap ( p : KtNDArray < T > , discont : Double = PI , axis : Int = - ) : KtNDArray < Double >","body":"= callFunc ( nameMethod = arrayOf ( \"\" ) , args = arrayOf ( p , discont , axis ) )","docstring":"/**\n * Unwrap by changing deltas between values to 2*pi complement.\n */"} {"signature":"fun < T : Number > deg2rad ( x : KtNDArray < T > ) : KtNDArray < Double >","body":"= callFunc ( nameMethod = arrayOf ( \"\" ) , args = arrayOf ( x ) , dtype = Double :: class )","docstring":"/**\n * Convert angles from degrees to radians.\n */"} {"signature":"fun < T : Number > rad2deg ( x : KtNDArray < T > ) : KtNDArray < Double >","body":"= callFunc ( nameMethod = arrayOf ( \"\" ) , args = arrayOf ( x ) , dtype = Double :: class )","docstring":"/**\n * Convert angles from radians to degrees.\n */"} {"signature":"private fun patchStackTrace ( node : TestNode , stackTrace : List < StackTraceElement > ? ) : List < StackTraceElement > ?","body":"= stackTrace ? . map { if ( it . className == node . classDisplayName ) StackTraceElement ( node . className , it . methodName , it . fileName , it . lineNumber ) else it }","docstring":"/**\n * Required for org.gradle.api.internal.tasks.testing.logging.ShortExceptionFormatter.printException\n * In JS Stacktraces we have short class name, while filter using FQN\n * So, let replace short class name with FQN for current test\n */"} {"signature":"private fun createReportingNode ( ) : TestDescriptorInternal","body":"{ val parents = collectParents ( ) val fullName = parents . reversed ( ) . map { it . cleanName } . filter { it . isNotBlank ( ) } . joinToString ( \"\" ) val reportingParent = parents . last ( ) as RootNode this . reportingParent = reportingParent descriptor = object : DefaultTestSuiteDescriptor ( id , fullName ) , LegacyTestDescriptorInternal { override fun getDisplayName ( ) : String = fullNameWithoutRoot override fun getClassName ( ) : String ? = fullNameWithoutRoot override fun getOwnerBuildOperationId ( ) : Any ? = rootOperationId override fun getParent ( ) : TestDescriptorInternal = reportingParent . descriptor override fun toString ( ) : String = displayName } shouldReportComplete = true check ( startedTs != ) reportStarted ( startedTs ) return descriptor ! ! }","docstring":"/**\n * Called when first test in suite started\n */"} {"signature":"public fun < DomainType : Comparable < DomainType > > PositionalMappingParametersContinuous < * > . continuous ( limits : ClosedRange < DomainType > , transform : PositionalTransform ? = null ) : PositionalContinuousScale < DomainType >","body":"= PositionalContinuousScale ( limits . start , limits . endInclusive , null , transform )","docstring":"/**\n * Creates a new continuous positional scale (with non-nullable domain).\n *\n * @param DomainType scale domain type.\n * @param limits [ClosedRange] defining the scale domain.\n * @param transform the transformation of scale.\n * @return new [PositionalContinuousScale] with given limits.\n */"} {"signature":"public fun < DomainType : Comparable < DomainType > > Scale . Companion . continuousPos ( limits : ClosedRange < DomainType > , transform : PositionalTransform ? = null ) : PositionalContinuousScale < DomainType >","body":"= PositionalContinuousScale ( limits . start , limits . endInclusive , null , transform )","docstring":"/**\n * Creates a new continuous positional scale (with non-nullable domain).\n *\n * @param DomainType scale domain type.\n * @param limits [ClosedRange] defining the scale domain.\n * @param transform the transformation of scale.\n * @return new [PositionalContinuousScale] with given limits.\n */"} {"signature":"public fun < DomainType : Comparable < DomainType > > PositionalMappingParametersContinuous < * > . continuous ( limits : ClosedRange < DomainType > , nullValue : DomainType ? = null , transform : PositionalTransform ? = null ) : PositionalContinuousScale < DomainType ? >","body":"= PositionalContinuousScale ( limits . start , limits . endInclusive , nullValue , transform )","docstring":"/**\n * Creates a new continuous positional scale (with nullable domain).\n *\n * @param DomainType scale domain type.\n * @param limits [ClosedRange] defining the scale domain.\n * @param nullValue value which null is mapped to.\n * @param transform the transformation of scale.\n * @return new [PositionalContinuousScale] with given limits.\n */"} {"signature":"public fun < DomainType : Comparable < DomainType > > Scale . Companion . continuousPos ( limits : ClosedRange < DomainType > , nullValue : DomainType ? = null , transform : PositionalTransform ? = null ) : PositionalContinuousScale < DomainType ? >","body":"= PositionalContinuousScale ( limits . start , limits . endInclusive , nullValue , transform )","docstring":"/**\n * Creates a new continuous positional scale (with nullable domain).\n *\n * @param DomainType scale domain type.\n * @param limits [ClosedRange] defining the scale domain.\n * @param nullValue value which null is mapped to.\n * @param transform the transformation of scale.\n * @return new [PositionalContinuousScale] with given limits.\n */"} {"signature":"public fun < DomainType > PositionalMappingParametersContinuous < * > . continuous ( min : DomainType ? = null , max : DomainType ? = null , transform : PositionalTransform ? = null ) : PositionalContinuousScale < DomainType >","body":"= PositionalContinuousScale ( min , max , null , transform )","docstring":"/**\n * Creates a new continuous positional scale (with non-nullable domain).\n *\n * @param DomainType scale domain type.\n * @param min scale domain minimum.\n * @param max scale domain maximum.\n * @param transform the transformation of scale.\n * @return new [PositionalContinuousScale] with given limits.\n */"} {"signature":"public fun < DomainType > Scale . Companion . continuousPos ( min : DomainType ? = null , max : DomainType ? = null , transform : PositionalTransform ? = null ) : PositionalContinuousScale < DomainType >","body":"= PositionalContinuousScale ( min , max , null , transform )","docstring":"/**\n * Creates a new continuous positional scale (with non-nullable domain).\n *\n * @param DomainType scale domain type.\n * @param min scale domain minimum.\n * @param max scale domain maximum.\n * @param transform the transformation of scale.\n * @return new [PositionalContinuousScale] with given limits.\n */"} {"signature":"public fun < DomainType > PositionalMappingParametersContinuous < * > . continuous ( min : DomainType ? = null , max : DomainType ? = null , nullValue : DomainType ? = null , transform : PositionalTransform ? = null ) : PositionalContinuousScale < DomainType ? >","body":"= PositionalContinuousScale ( min , max , nullValue , transform )","docstring":"/**\n * Creates a new continuous positional scale (with nullable domain).\n *\n * @param DomainType scale domain type.\n * @param min scale domain minimum.\n * @param max scale domain maximum.\n * @param nullValue value which null is mapped to.\n * @param transform the transformation of scale.\n * @return new [PositionalContinuousScale] with given limits.\n */"} {"signature":"public fun < DomainType > Scale . Companion . continuousPos ( min : DomainType ? = null , max : DomainType ? = null , nullValue : DomainType ? = null , transform : PositionalTransform ? = null ) : PositionalContinuousScale < DomainType ? >","body":"= PositionalContinuousScale ( min , max , nullValue , transform )","docstring":"/**\n * Creates a new continuous positional scale (with nullable domain).\n *\n * @param DomainType scale domain type.\n * @param min scale domain minimum.\n * @param max scale domain maximum.\n * @param nullValue value which null is mapped to.\n * @param transform the transformation of scale.\n * @return new [PositionalContinuousScale] with given limits.\n */"} {"signature":"public fun < DomainType > PositionalMappingParameters < * > . categorical ( categories : List < DomainType > ? = null , ) : PositionalCategoricalScale < DomainType >","body":"= PositionalCategoricalScale ( categories )","docstring":"/**\n * Creates a new categorical positional scale.\n *\n * @param DomainType scale domain type.\n * @param categories [List] defining the scale domain.\n * @return new [PositionalCategoricalScale] with given categories.\n */"} {"signature":"public fun < DomainType > Scale . Companion . categoricalPos ( categories : List < DomainType > ? = null , ) : PositionalCategoricalScale < DomainType >","body":"= PositionalCategoricalScale ( categories )","docstring":"/**\n * Creates a new categorical positional scale.\n *\n * @param DomainType scale domain type.\n * @param categories [List] defining the scale domain.\n * @return new [PositionalCategoricalScale] with given categories.\n */"} {"signature":"public fun < RangeType : Comparable < RangeType > , DomainType > NonPositionalMappingParametersContinuous < * , * > . continuous ( range : ClosedRange < RangeType > , nullValue : RangeType ? = null , transform : NonPositionalTransform ? = null ) : NonPositionalContinuousScale < DomainType , RangeType >","body":"= NonPositionalContinuousScale ( null , null , range . start , range . endInclusive , nullValue , transform )","docstring":"/**\n * Creates a new continuous non-positional scale.\n *\n * @param DomainType scale domain type.\n * @param RangeType type of the scale range.\n * @param range [ClosedRange] defining the scale range.\n * @param nullValue value which null is mapped to.\n * @param transform scale transformation.\n * @return new [NonPositionalContinuousScale] with the given range.\n */"} {"signature":"public fun < RangeType : Comparable < RangeType > , DomainType > Scale . Companion . continuous ( range : ClosedRange < RangeType > , nullValue : RangeType ? = null , transform : NonPositionalTransform ? = null ) : NonPositionalContinuousScale < DomainType , RangeType >","body":"= NonPositionalContinuousScale ( null , null , range . start , range . endInclusive , nullValue , transform )","docstring":"/**\n * Creates a new continuous non-positional scale.\n *\n * @param DomainType scale domain type.\n * @param RangeType type of the scale range.\n * @param range [ClosedRange] defining the scale range.\n * @param nullValue value which null is mapped to.\n * @param transform scale transformation.\n * @return new [NonPositionalContinuousScale] with the given range.\n */"} {"signature":"public fun < RangeType : Comparable < RangeType > , DomainType : Comparable < DomainType > > NonPositionalMappingParametersContinuous < * , * > . continuous ( range : ClosedRange < RangeType > ? = null , domain : ClosedRange < DomainType > , nullValue : RangeType ? = null , transform : NonPositionalTransform ? = null ) : NonPositionalContinuousScale < DomainType , RangeType >","body":"= NonPositionalContinuousScale ( domain . start , domain . endInclusive , range ? . start , range ? . endInclusive , nullValue , transform )","docstring":"/**\n * Creates a new continuous non-positional scale.\n *\n * @param DomainType scale domain type.\n * @param RangeType type of the scale range.\n * @param range [ClosedRange] defining the scale range.\n * @param domain [ClosedRange] defining the scale domain.\n * @param nullValue value which null is mapped to.\n * @param transform scale transformation.\n * @return new [NonPositionalContinuousScale] with the given domain and range.\n */"} {"signature":"public fun < RangeType : Comparable < RangeType > , DomainType : Comparable < DomainType > > Scale . Companion . continuous ( range : ClosedRange < RangeType > ? = null , domain : ClosedRange < DomainType > , nullValue : RangeType ? = null , transform : NonPositionalTransform ? = null ) : NonPositionalContinuousScale < DomainType , RangeType >","body":"= NonPositionalContinuousScale ( domain . start , domain . endInclusive , range ? . start , range ? . endInclusive , nullValue , transform )","docstring":"/**\n * Creates a new continuous non-positional scale.\n *\n * @param DomainType scale domain type.\n * @param RangeType type of the scale range.\n * @param range [ClosedRange] defining the scale range.\n * @param domain [ClosedRange] defining the scale domain.\n * @param nullValue value which null is mapped to.\n * @param transform scale transformation.\n * @return new [NonPositionalContinuousScale] with the given domain and range.\n */"} {"signature":"public fun < RangeType , DomainType > NonPositionalMappingParametersContinuous < * , * > . continuous ( rangeMin : RangeType ? = null , rangeMax : RangeType ? = null , domainMin : DomainType ? = null , domainMax : DomainType ? = null , nullValue : RangeType ? = null , transform : NonPositionalTransform ? = null ) : NonPositionalContinuousScale < DomainType , RangeType >","body":"= NonPositionalContinuousScale ( domainMin , domainMax , rangeMin , rangeMax , nullValue , transform )","docstring":"/**\n * Creates a new continuous non-positional scale.\n *\n * @param DomainType scale domain type.\n * @param RangeType type of the scale range.\n * @param rangeMin scale range minimum.\n * @param rangeMax scale range maximum.\n * @param domainMin scale domain minimum.\n * @param domainMax scale domain maximum.\n * @param nullValue value which null is mapped to.\n * @param transform scale transformation.\n * @return new [NonPositionalContinuousScale] with the given domain and range.\n */"} {"signature":"public fun < RangeType , DomainType > Scale . Companion . continuous ( rangeMin : RangeType ? = null , rangeMax : RangeType ? = null , domainMin : DomainType ? = null , domainMax : DomainType ? = null , nullValue : RangeType ? = null , transform : NonPositionalTransform ? = null ) : NonPositionalContinuousScale < DomainType , RangeType >","body":"= NonPositionalContinuousScale ( domainMin , domainMax , rangeMin , rangeMax , nullValue , transform )","docstring":"/**\n * Creates a new continuous non-positional scale.\n *\n * @param DomainType scale domain type.\n * @param RangeType type of the scale range.\n * @param rangeMin scale range minimum.\n * @param rangeMax scale range maximum.\n * @param domainMin scale domain minimum.\n * @param domainMax scale domain maximum.\n * @param nullValue value which null is mapped to.\n * @param transform scale transformation.\n * @return new [NonPositionalContinuousScale] with the given domain and range.\n */"} {"signature":"public inline fun < reified RangeType , reified DomainType > NonPositionalMappingParameters < * , * > . categorical ( range : List < RangeType > ? = null , domain : List < DomainType > ? = null , ) : NonPositionalCategoricalScale < DomainType , RangeType >","body":"= NonPositionalCategoricalScale ( domain , range )","docstring":"/**\n * Creates a new categorical non-positional scale.\n *\n * @param DomainType scale domain type.\n * @param RangeType type of the scale range.\n * @param range [List] defining the scale range.\n * @param domain [List] defining the scale domain.\n * @return new [NonPositionalCategoricalScale] with given domain and range.\n */"} {"signature":"public inline fun < reified RangeType , reified DomainType > Scale . Companion . categorical ( range : List < RangeType > ? = null , domain : List < DomainType > ? = null , ) : NonPositionalCategoricalScale < DomainType , RangeType >","body":"= NonPositionalCategoricalScale ( domain , range )","docstring":"/**\n * Creates a new categorical non-positional scale.\n *\n * @param DomainType scale domain type.\n * @param RangeType type of the scale range.\n * @param range [List] defining the scale range.\n * @param domain [List] defining the scale domain.\n * @return new [NonPositionalCategoricalScale] with given domain and range.\n */"} {"signature":"public fun < DomainType , RangeType > NonPositionalMappingParameters < * , * > . categorical ( vararg categoriesToValues : Pair < DomainType , RangeType > , ) : NonPositionalCategoricalScale < DomainType , RangeType >","body":"= NonPositionalCategoricalScale ( categoriesToValues . map { it . first } , categoriesToValues . map { it . second } , )","docstring":"/**\n * Creates a new categorical non-positional scale.\n *\n * @param DomainType scale domain type.\n * @param RangeType type of the scale range.\n * @param categoriesToValues [List] of pairs of category to corresponding value.\n * @return new [NonPositionalCategoricalScale] by domain-to-range correspondence.\n */"} {"signature":"public fun < DomainType , RangeType > Scale . Companion . categorical ( vararg categoriesToValues : Pair < DomainType , RangeType > , ) : NonPositionalCategoricalScale < DomainType , RangeType >","body":"= NonPositionalCategoricalScale ( categoriesToValues . map { it . first } , categoriesToValues . map { it . second } , )","docstring":"/**\n * Creates a new categorical non-positional scale.\n *\n * @param DomainType scale domain type\n * @param RangeType type of the scale range\n * @param categoriesToValues [List] of pairs of category to corresponding value.\n * @return new [NonPositionalCategoricalScale] by domain-to-range correspondence.\n */"} {"signature":"fun buildBalancedOrExpressionTree ( conditions : List < FirExpression > , lower : Int = , upper : Int = conditions . lastIndex ) : FirExpression","body":"{ val size = upper - lower + val middle = size / + lower if ( lower == upper ) { return conditions [ middle ] } val leftNode = buildBalancedOrExpressionTree ( conditions , lower , middle - ) val rightNode = buildBalancedOrExpressionTree ( conditions , middle , upper ) return leftNode . generateLazyLogicalOperation ( rightNode , isAnd = false , ( leftNode . source ? : rightNode . source ) ? . fakeElement ( KtFakeSourceElementKind . WhenCondition ) ) }","docstring":"/**\n * Creates balanced tree of OR expressions for given set of conditions\n * We do so, to avoid too deep OR-expression structures, that can cause running out of stack while processing\n * [conditions] should contain at least one element, otherwise it will cause StackOverflow\n */"} {"signature":"@ HtmlTagMarker inline fun SELECT . option ( classes : String ? = null , crossinline block : OPTION . ( ) -> Unit = { } ) : Unit","body":"= OPTION ( attributesMapOf ( \"\" , classes ) , consumer ) . visit ( block )","docstring":"/**\n * Selectable choice\n */"} {"signature":"@ HtmlTagMarker fun SELECT . option ( classes : String ? = null , content : String = \"\" ) : Unit","body":"= OPTION ( attributesMapOf ( \"\" , classes ) , consumer ) . visit ( { + content } )","docstring":"/**\n * Selectable choice\n */"} {"signature":"@ HtmlTagMarker inline fun SELECT . optGroup ( label : String ? = null , classes : String ? = null , crossinline block : OPTGROUP . ( ) -> Unit = { } ) : Unit","body":"= OPTGROUP ( attributesMapOf ( \"\" , label , \"\" , classes ) , consumer ) . visit ( block )","docstring":"/**\n * Option group\n */"} {"signature":"public fun < C > getCol ( accessor : ColumnReference < C > ) : ColumnWithPath < C > ?","body":"= asColumnGroup ( ) . getColumnOrNull ( accessor ) ? . addPath ( path + accessor . path ( ) )","docstring":"/**\n * Casts this column to a [ColumnGroup] and returns a column with the specified [accessor] or null if it\n * can't be found.\n */"} {"signature":"public fun getCol ( name : String ) : ColumnWithPath < Any ? > ?","body":"= asColumnGroup ( ) . getColumnOrNull ( name ) ? . addParentPath ( path )","docstring":"/**\n * Casts this column to a [ColumnGroup] and returns a column with the specified [name] or null if it\n * can't be found.\n */"} {"signature":"public fun getCol ( index : Int ) : ColumnWithPath < Any ? > ?","body":"= asColumnGroup ( ) . getColumnOrNull ( index ) ? . addParentPath ( path )","docstring":"/**\n * Casts this column to a [ColumnGroup] and returns a column with the specified [index] or null if it\n * can't be found.\n */"} {"signature":"public fun < C > getCol ( accessor : KProperty < C > ) : ColumnWithPath < C > ?","body":"= asColumnGroup ( ) . getColumnOrNull ( accessor ) ? . addParentPath ( path )","docstring":"/**\n * Casts this column to a [ColumnGroup] and returns a column with the specified [accessor] or null if it\n * can't be found.\n */"} {"signature":"public fun cols ( ) : List < ColumnWithPath < Any ? > >","body":"= if ( isColumnGroup ( ) ) { data . asColumnGroup ( ) . columns ( ) . map { it . addParentPath ( path ) } } else { emptyList ( ) }","docstring":"/**\n * Returns all (\"children\") columns in this column if it's a group, else it returns an empty list.\n */"} {"signature":"public fun KtExpression . evaluate ( mode : KtConstantEvaluationMode ) : KtConstantValue ?","body":"= withValidityAssertion { analysisSession . compileTimeConstantProvider . evaluate ( this , mode ) }","docstring":"/**\n * Tries to evaluate the provided expression using the specified mode.\n * Returns a [KtConstantValue] if the expression evaluates to a compile-time constant, otherwise returns null..\n */"} {"signature":"public fun KtExpression . evaluateAsAnnotationValue ( ) : KtAnnotationValue ?","body":"= withValidityAssertion { analysisSession . compileTimeConstantProvider . evaluateAsAnnotationValue ( this ) }","docstring":"/**\n * Returns a [KtConstantValue] if the expression evaluates to a value that can be used as an annotation parameter value,\n * e.g. an array of constants, otherwise returns null.\n */"} {"signature":"@ JvmStatic fun newInstance ( param1 : String , param2 : String )","body":"= DestinationFragment1 ( ) . apply { arguments = Bundle ( ) . apply { putString ( ARG_PARAM1 , param1 ) putString ( ARG_PARAM2 , param2 ) } }","docstring":"/**\n * Use this factory method to create a new instance of\n * this fragment using the provided parameters.\n *\n * @param param1 Parameter 1.\n * @param param2 Parameter 2.\n * @return A new instance of fragment DestinationFragment1.\n */"} {"signature":"abstract override fun hashCode ( ) : Int","body":"abstract override fun hashCode ( ) : Int","docstring":"/** Implementation must compute the hashcode from the source element. */"} {"signature":"abstract override fun equals ( other : Any ? ) : Boolean","body":"abstract override fun equals ( other : Any ? ) : Boolean","docstring":"/** Elements of the same source should be considered equal. */"} {"signature":"fun unwrapToKtPsiSourceElement ( ) : KtPsiSourceElement ?","body":"{ if ( treeStructure !is KtPsiSourceElement . WrappedTreeStructure ) return null val node = treeStructure . unwrap ( lighterASTNode ) return node . psi ? . toKtPsiSourceElement ( kind ) }","docstring":"/**\n * We can create a [KtLightSourceElement] from a [KtPsiSourceElement] by using [KtPsiSourceElement.lighterASTNode];\n * [unwrapToKtPsiSourceElement] allows to get original [KtPsiSourceElement] in such case.\n *\n * If it is `pure` [KtLightSourceElement], i.e, compiler created it in light tree mode, then return [unwrapToKtPsiSourceElement] `null`.\n * Otherwise, return some not-null result.\n */"} {"signature":"expect fun < T > CoroutineScope . asyncWithDealy ( delay : Long , block : suspend ( ) -> T ) : Deferred < T >","body":"expect fun < T > CoroutineScope . asyncWithDealy ( delay : Long , block : suspend ( ) -> T ) : Deferred < T >","docstring":"/**\n * Common `expect` declaration\n */"} {"signature":"fun CoroutineDispatcher . name ( ) : String","body":"= TODO ( \"\" )","docstring":"/**\n * Common coroutine extension\n */"} {"signature":"private fun produceObjCFramework ( engine : PhaseEngine < PhaseContext > , config : KonanConfig , environment : KotlinCoreEnvironment )","body":"{ val frontendOutput = engine . runFrontend ( config , environment ) ? : return val objCExportedInterface = engine . runPhase ( ProduceObjCExportInterfacePhase , frontendOutput ) engine . runPhase ( CreateObjCFrameworkPhase , CreateObjCFrameworkInput ( frontendOutput . moduleDescriptor , objCExportedInterface ) ) if ( config . omitFrameworkBinary ) { return } val ( psiToIrOutput , objCCodeSpec ) = engine . runPsiToIr ( frontendOutput , isProducingLibrary = false ) { it . runPhase ( CreateObjCExportCodeSpecPhase , objCExportedInterface ) } require ( psiToIrOutput is PsiToIrOutput . ForBackend ) val backendContext = createBackendContext ( config , frontendOutput , psiToIrOutput ) { it . objCExportedInterface = objCExportedInterface it . objCExportCodeSpec = objCCodeSpec } engine . runBackend ( backendContext , psiToIrOutput . irModule ) }","docstring":"/**\n * Create an Objective-C framework which is a directory consisting of\n * - Objective-C header\n * - Info.plist\n * - Binary (if -Xomit-framework-binary is not passed).\n */"} {"signature":"private fun produceBinary ( engine : PhaseEngine < PhaseContext > , config : KonanConfig , environment : KotlinCoreEnvironment )","body":"{ val frontendOutput = engine . runFrontend ( config , environment ) ? : return val psiToIrOutput = engine . runPsiToIr ( frontendOutput , isProducingLibrary = false ) require ( psiToIrOutput is PsiToIrOutput . ForBackend ) val backendContext = createBackendContext ( config , frontendOutput , psiToIrOutput ) engine . runBackend ( backendContext , psiToIrOutput . irModule ) }","docstring":"/**\n * Produce a single binary artifact.\n */"} {"signature":"private fun produceBundle ( engine : PhaseEngine < PhaseContext > , config : KonanConfig , environment : KotlinCoreEnvironment )","body":"{ require ( config . target . family . isAppleFamily ) require ( config . produce == CompilerOutputKind . TEST_BUNDLE ) val frontendOutput = engine . runFrontend ( config , environment ) ? : return engine . runPhase ( CreateTestBundlePhase , frontendOutput ) val psiToIrOutput = engine . runPsiToIr ( frontendOutput , isProducingLibrary = false ) require ( psiToIrOutput is PsiToIrOutput . ForBackend ) val backendContext = createBackendContext ( config , frontendOutput , psiToIrOutput ) engine . runBackend ( backendContext , psiToIrOutput . irModule ) }","docstring":"/**\n * Produce a bundle that is a directory with code and resources.\n * It consists of\n * - Info.plist\n * - Binary without an entry point.\n *\n * See https://developer.apple.com/library/archive/documentation/CoreFoundation/Conceptual/CFBundles/AboutBundles/AboutBundles.html\n */"} {"signature":"override fun matches ( startIndex : Int , testString : CharSequence , matchResult : MatchResultImpl ) : Int","body":"{ if ( children . isEmpty ( ) ) { return - } val oldStart = matchResult . getStart ( groupIndex ) matchResult . setStart ( groupIndex , startIndex ) children . forEach { val shift = it . matches ( startIndex , testString , matchResult ) if ( shift >= ) { return shift } } matchResult . setStart ( groupIndex , oldStart ) return - }","docstring":"/**\n * Returns startIndex+shift, the next position to match\n */"} {"signature":"internal fun prepareKotlinNativeBundle ( project : Project , kotlinNativeBundleConfiguration : ConfigurableFileCollection , kotlinNativeVersion : String , bundleDir : File , reinstallFlag : Boolean , konanTargets : Set < KonanTarget > , overriddenKonanHome : String ? , )","body":"{ if ( overriddenKonanHome != null ) { project . logger . info ( \"\" ) } else { processToolchain ( bundleDir , project , reinstallFlag , kotlinNativeVersion , kotlinNativeBundleConfiguration ) } project . setupKotlinNativePlatformLibraries ( konanTargets ) }","docstring":"/**\n * This function downloads and installs a Kotlin Native bundle if needed\n * and then prepares its platform libraries if needed.\n *\n * @param project The Gradle project object.\n * @param kotlinNativeBundleConfiguration Gradle configuration for Kotlin Native Bundle\n * @param kotlinNativeVersion The version of Kotlin/Native to install\n * @param bundleDir The directory to store the Kotlin/Native bundle.\n * @param reinstallFlag A flag indicating whether to reinstall the bundle.\n * @param konanTargets The set of KonanTarget objects representing the targets for the Kotlin/Native bundle.\n * @param overriddenKonanHome Overridden konan home if present.\n * @return kotlin native version if toolchain was used, path to konan home if konan home was used\n */"} {"signature":"internal fun downloadNativeDependencies ( bundleDir : File , konanDataDir : String ? , konanTargets : Set < KonanTarget > , logger : Logger , ) : Set < String >","body":"{ val requiredDependencies = mutableSetOf < String > ( ) val distribution = Distribution ( bundleDir . absolutePath , konanDataDir = konanDataDir ) konanTargets . forEach { konanTarget -> if ( konanTarget . enabledOnCurrentHostForBinariesCompilation ( ) ) { val konanPropertiesLoader = loadConfigurables ( konanTarget , distribution . properties , distribution . dependenciesDir , progressCallback = { url , currentBytes , totalBytes -> logger . info ( \"\" ) } ) as KonanPropertiesLoader requiredDependencies . addAll ( konanPropertiesLoader . dependencies ) konanPropertiesLoader . downloadDependencies ( DependencyExtractor ( ) ) } } return requiredDependencies }","docstring":"/**\n * Downloads native dependencies for Kotlin Native based on the provided configuration.\n * @return A set of required dependencies that were downloaded.\n */"} {"signature":"public fun < T > yBegin ( column : ColumnReference < T > ) : PositionalMapping < T >","body":"{ return addPositionalMapping < T > ( Y_BEGIN , column . name ( ) , null ) }","docstring":"/**\n * Maps the `yBegin` aesthetic to a data column by [ColumnReference].\n *\n * @param column the data column to be mapped.\n * @return a [PositionalMapping] object representing the mapping.\n */"} {"signature":"public fun < T > yBegin ( column : KProperty < T > ) : PositionalMapping < T >","body":"{ return addPositionalMapping < T > ( Y_BEGIN , column . name , null ) }","docstring":"/**\n * Maps the `yBegin` aesthetic to a data column by [KProperty].\n *\n * @param column the data column to be mapped.\n * @return a [PositionalMapping] object representing the mapping.\n */"} {"signature":"public fun yBegin ( column : String ) : PositionalMapping < Any ? >","body":"{ return addPositionalMapping ( Y_BEGIN , column , null ) }","docstring":"/**\n * Maps the `yBegin` aesthetic to a data column by [String].\n *\n * @param column the data column to be mapped.\n * @return a [PositionalMapping] object representing the mapping.\n */"} {"signature":"public fun < T > yBegin ( values : Iterable < T > ) : PositionalMapping < T >","body":"{ return addPositionalMapping < T > ( Y_BEGIN , values . toList ( ) , null , null ) }","docstring":"/**\n * Maps the `yBegin` aesthetic to iterable of values.\n *\n * @param values the iterable of values to be mapped.\n * @return a [PositionalMapping] object representing the mapping.\n */"} {"signature":"public fun < T > yBegin ( values : DataColumn < T > ) : PositionalMapping < T >","body":"{ return addPositionalMapping < T > ( Y_BEGIN , values , null ) }","docstring":"/**\n * Maps the `yBegin` aesthetic to a data column.\n *\n * @param values the data column to be mapped.\n * @return a [PositionalMapping] object representing the mapping.\n */"} {"signature":"private fun < T > Flow < T > . idScoped ( ) : Flow < T >","body":"= flow { coroutineScope { val channel = produce { collect { send ( it ) } } channel . consumeEach { emit ( it ) } } }","docstring":"/**\n * This flow should be \"identity\" function with respect to cancellation.\n */"} {"signature":"public fun KtExpression . getSmartCastInfo ( ) : KtSmartCastInfo ?","body":"= withValidityAssertion { analysisSession . smartCastProvider . getSmartCastedInfo ( this ) }","docstring":"/**\n * Gets the smart-cast information of the given expression or null if the expression is not smart casted.\n */"} {"signature":"public fun KtExpression . getImplicitReceiverSmartCast ( ) : Collection < KtImplicitReceiverSmartCast >","body":"= withValidityAssertion { analysisSession . smartCastProvider . getImplicitReceiverSmartCast ( this ) }","docstring":"/**\n * Returns the list of implicit smart-casts which are required for the expression to be called. Includes only implicit\n * smart-casts:\n *\n * ```kt\n * if (this is String) {\n * this.substring() // 'this' receiver is explicit, so no implicit smart-cast here.\n *\n * smartcast() // 'this' receiver is implicit, therefore there is implicit smart-cast involved.\n * }\n * ```\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ ExperimentalUnsignedTypes @ kotlin . internal . InlineOnly public actual inline fun UIntArray . elementAt ( index : Int ) : UInt","body":"{ return get ( index ) }","docstring":"/**\n * Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.\n * \n * @sample samples.collections.Collections.Elements.elementAt\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ ExperimentalUnsignedTypes @ kotlin . internal . InlineOnly public actual inline fun ULongArray . elementAt ( index : Int ) : ULong","body":"{ return get ( index ) }","docstring":"/**\n * Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.\n * \n * @sample samples.collections.Collections.Elements.elementAt\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ ExperimentalUnsignedTypes @ kotlin . internal . InlineOnly public actual inline fun UByteArray . elementAt ( index : Int ) : UByte","body":"{ return get ( index ) }","docstring":"/**\n * Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.\n * \n * @sample samples.collections.Collections.Elements.elementAt\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ ExperimentalUnsignedTypes @ kotlin . internal . InlineOnly public actual inline fun UShortArray . elementAt ( index : Int ) : UShort","body":"{ return get ( index ) }","docstring":"/**\n * Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.\n * \n * @sample samples.collections.Collections.Elements.elementAt\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ ExperimentalUnsignedTypes public actual fun UIntArray . asList ( ) : List < UInt >","body":"{ return object : AbstractList < UInt > ( ) , RandomAccess { override val size : Int get ( ) = this@asList . size override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) override fun contains ( element : UInt ) : Boolean = this@asList . contains ( element ) override fun get ( index : Int ) : UInt = this@asList [ index ] override fun indexOf ( element : UInt ) : Int = this@asList . indexOf ( element ) override fun lastIndexOf ( element : UInt ) : Int = this@asList . lastIndexOf ( element ) } }","docstring":"/**\n * Returns a [List] that wraps the original array.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ ExperimentalUnsignedTypes public actual fun ULongArray . asList ( ) : List < ULong >","body":"{ return object : AbstractList < ULong > ( ) , RandomAccess { override val size : Int get ( ) = this@asList . size override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) override fun contains ( element : ULong ) : Boolean = this@asList . contains ( element ) override fun get ( index : Int ) : ULong = this@asList [ index ] override fun indexOf ( element : ULong ) : Int = this@asList . indexOf ( element ) override fun lastIndexOf ( element : ULong ) : Int = this@asList . lastIndexOf ( element ) } }","docstring":"/**\n * Returns a [List] that wraps the original array.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ ExperimentalUnsignedTypes public actual fun UByteArray . asList ( ) : List < UByte >","body":"{ return object : AbstractList < UByte > ( ) , RandomAccess { override val size : Int get ( ) = this@asList . size override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) override fun contains ( element : UByte ) : Boolean = this@asList . contains ( element ) override fun get ( index : Int ) : UByte = this@asList [ index ] override fun indexOf ( element : UByte ) : Int = this@asList . indexOf ( element ) override fun lastIndexOf ( element : UByte ) : Int = this@asList . lastIndexOf ( element ) } }","docstring":"/**\n * Returns a [List] that wraps the original array.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ ExperimentalUnsignedTypes public actual fun UShortArray . asList ( ) : List < UShort >","body":"{ return object : AbstractList < UShort > ( ) , RandomAccess { override val size : Int get ( ) = this@asList . size override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) override fun contains ( element : UShort ) : Boolean = this@asList . contains ( element ) override fun get ( index : Int ) : UShort = this@asList [ index ] override fun indexOf ( element : UShort ) : Int = this@asList . indexOf ( element ) override fun lastIndexOf ( element : UShort ) : Int = this@asList . lastIndexOf ( element ) } }","docstring":"/**\n * Returns a [List] that wraps the original array.\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) @ ExperimentalUnsignedTypes public infix fun UIntArray . contentEquals ( other : UIntArray ) : Boolean","body":"{ return this . contentEquals ( other ) }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.intArrayContentEquals\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) @ ExperimentalUnsignedTypes public infix fun ULongArray . contentEquals ( other : ULongArray ) : Boolean","body":"{ return this . contentEquals ( other ) }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.intArrayContentEquals\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) @ ExperimentalUnsignedTypes public infix fun UByteArray . contentEquals ( other : UByteArray ) : Boolean","body":"{ return this . contentEquals ( other ) }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.intArrayContentEquals\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) @ ExperimentalUnsignedTypes public infix fun UShortArray . contentEquals ( other : UShortArray ) : Boolean","body":"{ return this . contentEquals ( other ) }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.intArrayContentEquals\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) @ ExperimentalUnsignedTypes public fun UIntArray . contentHashCode ( ) : Int","body":"{ return this . contentHashCode ( ) }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) @ ExperimentalUnsignedTypes public fun ULongArray . contentHashCode ( ) : Int","body":"{ return this . contentHashCode ( ) }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) @ ExperimentalUnsignedTypes public fun UByteArray . contentHashCode ( ) : Int","body":"{ return this . contentHashCode ( ) }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) @ ExperimentalUnsignedTypes public fun UShortArray . contentHashCode ( ) : Int","body":"{ return this . contentHashCode ( ) }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) @ ExperimentalUnsignedTypes public fun UIntArray . contentToString ( ) : String","body":"{ return this . contentToString ( ) }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) @ ExperimentalUnsignedTypes public fun ULongArray . contentToString ( ) : String","body":"{ return this . contentToString ( ) }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) @ ExperimentalUnsignedTypes public fun UByteArray . contentToString ( ) : String","body":"{ return this . contentToString ( ) }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) @ ExperimentalUnsignedTypes public fun UShortArray . contentToString ( ) : String","body":"{ return this . contentToString ( ) }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"} {"signature":"@ JvmName ( \"\" ) public fun LinAlg . plu ( mat : MultiArray < Float , D2 > ) : Triple < D2Array < Float > , D2Array < Float > , D2Array < Float > >","body":"= this . linAlgEx . pluF ( mat )","docstring":"/**\n * Returns PLU decomposition of the float matrix\n */"} {"signature":"@ JvmName ( \"\" ) public fun < T : Number > LinAlg . plu ( mat : MultiArray < T , D2 > ) : Triple < D2Array < Double > , D2Array < Double > , D2Array < Double > >","body":"= this . linAlgEx . plu ( mat )","docstring":"/**\n * Returns PLU decomposition of the numeric matrix\n */"} {"signature":"@ JvmName ( \"\" ) public fun < T : Complex > LinAlg . plu ( mat : MultiArray < T , D2 > ) : Triple < D2Array < T > , D2Array < T > , D2Array < T > >","body":"= this . linAlgEx . pluC ( mat )","docstring":"/**\n * Returns PLU decomposition of the complex matrix\n */"} {"signature":"private fun resolveThrowsTag ( tag : ThrowingExceptionJavadocTag , currentElement : PsiDocComment , ) : List < DocumentationContent >","body":"{ val closestDocsWithThrows = ( currentElement . owner as? PsiMethod ) ? . let { method -> lowestMethodsWithTag ( method , tag ) } . orEmpty ( ) . firstOrNull { docCommentFinder . findClosestToElement ( it ) ? . hasTag ( tag ) == true } ? : return emptyList ( ) return docCommentFactory . fromElement ( closestDocsWithThrows ) ? . resolveTag ( tag ) ? : emptyList ( ) }","docstring":"/**\n * Main resolution point for exception like tags\n *\n * This should be used only with [ThrowsJavadocTag] or [ExceptionJavadocTag] as their resolution path should be the same\n */"} {"signature":"protected open fun modulesFromDeserializers ( deserializers : Collection < IrModuleDeserializer > , excludedModuleIds : Set < ResolvedDependencyId > ) : Map < ResolvedDependencyId , ResolvedDependency >","body":"{ val modules : Map < ResolvedDependencyId , ModuleWithUninitializedDependencies > = deserializers . mapNotNull { deserializer -> val moduleId = getUserVisibleModuleId ( deserializer ) if ( moduleId in excludedModuleIds ) return@mapNotNull null val module = ResolvedDependency ( id = moduleId , selectedVersion = ResolvedDependencyVersion . EMPTY , requestedVersionsByIncomingDependencies = hashMapOf ( ResolvedDependencyId . DEFAULT_SOURCE_CODE_MODULE_ID to ResolvedDependencyVersion . EMPTY ) , artifactPaths = hashSetOf ( ) ) val outgoingDependencyIds = deserializer . moduleDependencies . map { getUserVisibleModuleId ( it ) } moduleId to ModuleWithUninitializedDependencies ( module , outgoingDependencyIds ) } . toMap ( ) return modules . stampDependenciesWithRequestedVersionEqualToSelectedVersion ( ) }","docstring":"/**\n * Load [ResolvedDependency]s that represent all libraries participating in the compilation. Includes external dependencies,\n * but without version and hierarchy information. Also includes the libraries that are not visible to the build system\n * (and therefore are missing in [ExternalDependenciesLoader.load]) but are provided by the compiler. For Kotlin/Native such\n * libraries are stdlib, endorsed and platform libraries.\n */"} {"signature":"protected fun mergedModules ( deserializers : Collection < IrModuleDeserializer > ) : MutableMap < ResolvedDependencyId , ResolvedDependency >","body":"{ val externalDependencyModulesByNames : Map < String , ResolvedDependency > = hashMapOf < String , ResolvedDependency > ( ) . apply { externalDependencyModules . forEach { externalDependency -> externalDependency . id . uniqueNames . forEach { uniqueName -> this [ uniqueName ] = externalDependency } } } fun findMatchingExternalDependencyModule ( moduleId : ResolvedDependencyId ) : ResolvedDependency ? = moduleId . uniqueNames . firstNotNullOfOrNull { uniqueName -> externalDependencyModulesByNames [ uniqueName ] } val artifactPathsToOriginModules : MutableMap < ResolvedDependencyArtifactPath , ResolvedDependency > = hashMapOf ( ) externalDependencyModules . forEach { originModule -> originModule . artifactPaths . forEach { artifactPath -> artifactPathsToOriginModules [ artifactPath ] = originModule } } val providedModules = mutableListOf < ResolvedDependency > ( ) modulesFromDeserializers ( deserializers = deserializers , excludedModuleIds = setOf ( sourceCodeModuleId ) ) . forEach { ( moduleId , module ) -> val externalDependencyModule = findMatchingExternalDependencyModule ( moduleId ) if ( externalDependencyModule != null ) { module . requestedVersionsByIncomingDependencies . forEach { ( incomingDependencyId , requestedVersion ) -> val adjustedIncomingDependencyId = findMatchingExternalDependencyModule ( incomingDependencyId ) ? . id ? : incomingDependencyId if ( adjustedIncomingDependencyId !in externalDependencyModule . requestedVersionsByIncomingDependencies ) { externalDependencyModule . requestedVersionsByIncomingDependencies [ adjustedIncomingDependencyId ] = requestedVersion } } } else { val originModuleVersion = module . artifactPaths . firstNotNullOfOrNull { artifactPathsToOriginModules [ it ] } ? . selectedVersion if ( originModuleVersion != null ) { module . selectedVersion = originModuleVersion val incomingDependencyIdsToStampRequestedVersion = module . requestedVersionsByIncomingDependencies . mapNotNull { ( incomingDependencyId , requestedVersion ) -> if ( requestedVersion . isEmpty ( ) ) incomingDependencyId else null } incomingDependencyIdsToStampRequestedVersion . forEach { incomingDependencyId -> module . requestedVersionsByIncomingDependencies [ incomingDependencyId ] = originModuleVersion } } else { if ( module . requestedVersionsByIncomingDependencies . isEmpty ( ) ) { module . requestedVersionsByIncomingDependencies [ sourceCodeModuleId ] = module . selectedVersion } } module . requestedVersionsByIncomingDependencies . mapNotNull { ( incomingDependencyId , requestedVersion ) -> val adjustedIncomingDependencyId = findMatchingExternalDependencyModule ( incomingDependencyId ) ? . id ? : return@mapNotNull null Triple ( incomingDependencyId , adjustedIncomingDependencyId , requestedVersion ) } . forEach { ( incomingDependencyId , adjustedIncomingDependencyId , requestedVersion ) -> module . requestedVersionsByIncomingDependencies . remove ( incomingDependencyId ) module . requestedVersionsByIncomingDependencies [ adjustedIncomingDependencyId ] = requestedVersion } providedModules += module } } return ( externalDependencyModules + providedModules ) . associateByTo ( hashMapOf ( ) ) { it . id } }","docstring":"/**\n * The result of the merge of [ExternalDependenciesLoader.load] and [modulesFromDeserializers].\n */"} {"signature":"fun getOrBuildFirFor ( element : KtElement ) : FirElement ?","body":"{ return if ( element is KtFile && element !is KtCodeFragment ) { getOrBuildFirForKtFile ( element ) } else { getFirForNonKtFileElement ( element ) } }","docstring":"/**\n * Returns a [FirElement] in its final resolved state.\n *\n * Note: that it isn't always [BODY_RESOLVE][FirResolvePhase.BODY_RESOLVE]\n * as not all declarations have types/bodies/etc. to resolve.\n *\n * For instance, [KtPackageDirective] has nothing to resolve,\n * so it will be returned as is ([FirPackageDirective][org.jetbrains.kotlin.fir.FirPackageDirective]),\n * with the [RAW_FIR][FirResolvePhase.RAW_FIR] phase.\n *\n * @return associated [FirElement] in final resolved state if it exists.\n *\n * @see getFirForElementInsideAnnotations\n * @see getFirForElementInsideTypes\n * @see getFirForElementInsideFileHeader\n */"} {"signature":"internal fun getNonLocalContainingDeclaration ( elementsToCheck : Sequence < PsiElement > , predicate : ( KtDeclaration ) -> Boolean = { true } , ) : KtDeclaration ?","body":"{ var candidate : KtDeclaration ? = null fun propose ( declaration : KtDeclaration ) { if ( candidate == null ) { candidate = declaration } } for ( parent in elementsToCheck ) { candidate ? . let { notNullCandidate -> if ( parent is KtEnumEntry || parent is KtCallableDeclaration && ! notNullCandidate . isPartOf ( parent ) || parent is KtAnonymousInitializer || parent is KtObjectLiteralExpression || parent is KtCallElement || parent is KtCodeFragment || parent is PsiErrorElement ) { candidate = null } } if ( candidate == null ) { when ( parent ) { is KtScript -> propose ( parent ) is KtDestructuringDeclaration -> propose ( parent ) is KtDestructuringDeclarationEntry -> propose ( parent ) is KtScriptInitializer -> propose ( parent ) is KtClassInitializer -> { val container = parent . containingDeclaration if ( ! container . isObjectLiteral ( ) && declarationCanBeLazilyResolved ( container ) && predicate ( parent ) ) { propose ( parent ) } } is KtDeclaration -> { if ( ! parent . isAutonomousDeclaration ) { if ( predicate ( parent ) ) { propose ( parent ) } } val isKindApplicable = when ( parent ) { is KtClassOrObject -> ! parent . isObjectLiteral ( ) is KtDeclarationWithBody , is KtProperty , is KtTypeAlias -> true else -> false } if ( isKindApplicable && declarationCanBeLazilyResolved ( parent ) && predicate ( parent ) ) { propose ( parent ) } } } } } return candidate }","docstring":"/**\n * Returns the first non-local declaration from [elementsToCheck] that contains the given elements,\n * based on the specified predicate.\n *\n * The resulting declaration can be considered reachable at [RAW_FIR][FirResolvePhase.RAW_FIR] phase.\n *\n * @see org.jetbrains.kotlin.analysis.low.level.api.fir.file.structure.FileStructure\n */"} {"signature":"public open fun encodeElement ( descriptor : SerialDescriptor , index : Int ) : Boolean","body":"= true","docstring":"/**\n * Invoked before writing an element that is part of the structure to determine whether it should be encoded.\n * Element information can be obtained from the [descriptor] by the given [index].\n *\n * @return `true` if the value should be encoded, false otherwise\n */"} {"signature":"public open fun encodeValue ( value : Any ) : Unit","body":"= throw SerializationException ( \"\" )","docstring":"/**\n * Invoked to encode a value when specialized `encode*` method was not overridden.\n */"} {"signature":"private fun createDelegateBody ( irField : IrField , delegatedFirDeclaration : FirCallableDeclaration , delegatedIrFunction : IrSimpleFunction , originalFirDeclaration : FirCallableDeclaration , originalFunctionSymbol : IrSimpleFunctionSymbol , isSetter : Boolean ) : IrBlockBody","body":"{ val startOffset = SYNTHETIC_OFFSET val endOffset = SYNTHETIC_OFFSET val body = irFactory . createBlockBody ( startOffset , endOffset ) val typeOrigin = when { originalFirDeclaration is FirPropertyAccessor && originalFirDeclaration . isSetter -> ConversionTypeOrigin . SETTER else -> ConversionTypeOrigin . DEFAULT } val callTypeCanBeNullable : Boolean val callReturnType = when ( isSetter ) { false -> { val substitution = originalFirDeclaration . typeParameters . zip ( delegatedFirDeclaration . typeParameters ) . map { ( original , delegated ) -> original . symbol to delegated . symbol . defaultType } . toMap ( ) val substitutor = substitutorByMap ( substitution , session ) val substitutedType = substitutor . substituteOrSelf ( originalFirDeclaration . returnTypeRef . coneType ) callTypeCanBeNullable = Fir2IrImplicitCastInserter . typeCanBeEnhancedOrFlexibleNullable ( substitutedType , session ) substitutedType . toIrType ( c , typeOrigin ) } true -> { callTypeCanBeNullable = false irBuiltIns . unitType } } val irCall = IrCallImpl ( startOffset , endOffset , callReturnType , originalFunctionSymbol , originalFirDeclaration . typeParameters . size , originalFirDeclaration . numberOfIrValueParameters ( isSetter ) ) . apply { val getField = IrGetFieldImpl ( startOffset , endOffset , irField . symbol , irField . type , IrGetValueImpl ( startOffset , endOffset , delegatedIrFunction . dispatchReceiverParameter ? . type ! ! , delegatedIrFunction . dispatchReceiverParameter ? . symbol ! ! ) ) val superFunctionDispatchReceiverType = originalFirDeclaration . dispatchReceiverType val superFunctionDispatchReceiverLookupTag = ( superFunctionDispatchReceiverType as? ConeClassLikeType ) ? . lookupTag val superFunctionParentSymbol = superFunctionDispatchReceiverLookupTag ? . let { classifierStorage . getIrClassSymbol ( it ) } dispatchReceiver = if ( superFunctionParentSymbol == null || irField . type . isSubtypeOfClass ( superFunctionParentSymbol ) ) { getField } else { Fir2IrImplicitCastInserter . implicitCastOrExpression ( getField , superFunctionDispatchReceiverType . toIrType ( c ) ) } extensionReceiver = delegatedIrFunction . extensionReceiverParameter ? . let { extensionReceiver -> IrGetValueImpl ( startOffset , endOffset , extensionReceiver . type , extensionReceiver . symbol ) } delegatedIrFunction . valueParameters . forEach { putValueArgument ( it . index , IrGetValueImpl ( startOffset , endOffset , it . type , it . symbol ) ) } for ( index in originalFirDeclaration . typeParameters . indices ) { putTypeArgument ( index , IrSimpleTypeImpl ( delegatedIrFunction . typeParameters [ index ] . symbol , hasQuestionMark = false , arguments = emptyList ( ) , annotations = emptyList ( ) ) ) } } val resultType = delegatedIrFunction . returnType val irCastOrCall = if ( callTypeCanBeNullable && ! resultType . isNullable ( ) ) Fir2IrImplicitCastInserter . implicitNotNullCast ( irCall ) else irCall val originalDeclarationReturnType = originalFirDeclaration . returnTypeRef . coneType if ( isSetter || originalDeclarationReturnType . isUnit || originalDeclarationReturnType . isNothing ) { body . statements . add ( irCastOrCall ) } else { val irReturn = IrReturnImpl ( startOffset , endOffset , irBuiltIns . nothingType , delegatedIrFunction . symbol , irCastOrCall ) body . statements . add ( irReturn ) } return body }","docstring":"/**\n * interface Base {\n * fun foo(): String\n * }\n *\n * class Impl : Base {\n * override fun foo(): String { <-------------- [originalFirFunction], [originalFunctionSymbol]\n * return \"OK\"\n * }\n * }\n *\n * class Delegated(impl: Impl) : Base by impl {\n * private field delegate_xxx: Impl = impl <-------------- [irField]\n * generated override fun foo(): String <-------------- [delegateFunction]\n * }\n *\n */"} {"signature":"public inline fun BarContext . background ( crossinline block : BackgroundStyle . ( ) -> Unit )","body":"{ BackgroundStyle ( this ) . apply ( block ) }","docstring":"/**\n * Sets background style for [bars][org.jetbrains.kotlinx.kandy.echarts.layers.bars].\n *\n * - [color][BackgroundStyle.color] - background [color][org.jetbrains.kotlinx.kandy.util.color.Color].\n * - [borderColor][BackgroundStyle.borderColor] -\n * background border [color][org.jetbrains.kotlinx.kandy.util.color.Color].\n * - [borderWidth][BackgroundStyle.borderWidth] - background border width.\n * By default `0`.\n * - [borderType][BackgroundStyle.borderType] - border [type][LineType].\n * By default `solid`.\n * - [borderRadius][BackgroundStyle.borderRadius] - background border radius.\n * By default `0`.\n * - [shadowBlur][BackgroundStyle.shadowBlur] - background shadow blur.\n * - [shadowColor][BackgroundStyle.shadowColor] -\n * background shadow [color][org.jetbrains.kotlinx.kandy.util.color.Color].\n * - [alpha][BackgroundStyle.alpha] - background opacity.\n *\n * ```kotlin\n * plot {\n * bars {\n * background {\n * color = Color.GREY\n * borderColor = Color.BLACK\n * borderWidth = 1.0\n * borderType = LineType.DASHED\n * borderRadius = 1.3\n * shadowBlur = 10.0\n * shadowColor = Color.GREEN\n * alpha = 0.7\n * }\n * }\n * }\n * ```\n *\n * @see org.jetbrains.kotlinx.kandy.echarts.layers.bars\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) @ kotlin . internal . InlineOnly public inline fun UInt . countOneBits ( ) : Int","body":"= toInt ( ) . countOneBits ( )","docstring":"/**\n * Counts the number of set bits in the binary representation of this [UInt] number.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) @ kotlin . internal . InlineOnly public inline fun UInt . countLeadingZeroBits ( ) : Int","body":"= toInt ( ) . countLeadingZeroBits ( )","docstring":"/**\n * Counts the number of consecutive most significant bits that are zero in the binary representation of this [UInt] number.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) @ kotlin . internal . InlineOnly public inline fun UInt . countTrailingZeroBits ( ) : Int","body":"= toInt ( ) . countTrailingZeroBits ( )","docstring":"/**\n * Counts the number of consecutive least significant bits that are zero in the binary representation of this [UInt] number.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) @ kotlin . internal . InlineOnly public inline fun UInt . takeHighestOneBit ( ) : UInt","body":"= toInt ( ) . takeHighestOneBit ( ) . toUInt ( )","docstring":"/**\n * Returns a number having a single bit set in the position of the most significant set bit of this [UInt] number,\n * or zero, if this number is zero.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) @ kotlin . internal . InlineOnly public inline fun UInt . takeLowestOneBit ( ) : UInt","body":"= toInt ( ) . takeLowestOneBit ( ) . toUInt ( )","docstring":"/**\n * Returns a number having a single bit set in the position of the least significant set bit of this [UInt] number,\n * or zero, if this number is zero.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ WasExperimental ( ExperimentalStdlibApi :: class , ExperimentalUnsignedTypes :: class ) @ kotlin . internal . InlineOnly public inline fun UInt . rotateLeft ( bitCount : Int ) : UInt","body":"= toInt ( ) . rotateLeft ( bitCount ) . toUInt ( )","docstring":"/**\n * Rotates the binary representation of this [UInt] number left by the specified [bitCount] number of bits.\n * The most significant bits pushed out from the left side reenter the number as the least significant bits on the right side.\n *\n * Rotating the number left by a negative bit count is the same as rotating it right by the negated bit count:\n * `number.rotateLeft(-n) == number.rotateRight(n)`\n *\n * Rotating by a multiple of [UInt.SIZE_BITS] (32) returns the same number, or more generally\n * `number.rotateLeft(n) == number.rotateLeft(n % 32)`\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ WasExperimental ( ExperimentalStdlibApi :: class , ExperimentalUnsignedTypes :: class ) @ kotlin . internal . InlineOnly public inline fun UInt . rotateRight ( bitCount : Int ) : UInt","body":"= toInt ( ) . rotateRight ( bitCount ) . toUInt ( )","docstring":"/**\n * Rotates the binary representation of this [UInt] number right by the specified [bitCount] number of bits.\n * The least significant bits pushed out from the right side reenter the number as the most significant bits on the left side.\n *\n * Rotating the number right by a negative bit count is the same as rotating it left by the negated bit count:\n * `number.rotateRight(-n) == number.rotateLeft(n)`\n *\n * Rotating by a multiple of [UInt.SIZE_BITS] (32) returns the same number, or more generally\n * `number.rotateRight(n) == number.rotateRight(n % 32)`\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) @ kotlin . internal . InlineOnly public inline fun ULong . countOneBits ( ) : Int","body":"= toLong ( ) . countOneBits ( )","docstring":"/**\n * Counts the number of set bits in the binary representation of this [ULong] number.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) @ kotlin . internal . InlineOnly public inline fun ULong . countLeadingZeroBits ( ) : Int","body":"= toLong ( ) . countLeadingZeroBits ( )","docstring":"/**\n * Counts the number of consecutive most significant bits that are zero in the binary representation of this [ULong] number.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) @ kotlin . internal . InlineOnly public inline fun ULong . countTrailingZeroBits ( ) : Int","body":"= toLong ( ) . countTrailingZeroBits ( )","docstring":"/**\n * Counts the number of consecutive least significant bits that are zero in the binary representation of this [ULong] number.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) @ kotlin . internal . InlineOnly public inline fun ULong . takeHighestOneBit ( ) : ULong","body":"= toLong ( ) . takeHighestOneBit ( ) . toULong ( )","docstring":"/**\n * Returns a number having a single bit set in the position of the most significant set bit of this [ULong] number,\n * or zero, if this number is zero.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) @ kotlin . internal . InlineOnly public inline fun ULong . takeLowestOneBit ( ) : ULong","body":"= toLong ( ) . takeLowestOneBit ( ) . toULong ( )","docstring":"/**\n * Returns a number having a single bit set in the position of the least significant set bit of this [ULong] number,\n * or zero, if this number is zero.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ WasExperimental ( ExperimentalStdlibApi :: class , ExperimentalUnsignedTypes :: class ) @ kotlin . internal . InlineOnly public inline fun ULong . rotateLeft ( bitCount : Int ) : ULong","body":"= toLong ( ) . rotateLeft ( bitCount ) . toULong ( )","docstring":"/**\n * Rotates the binary representation of this [ULong] number left by the specified [bitCount] number of bits.\n * The most significant bits pushed out from the left side reenter the number as the least significant bits on the right side.\n *\n * Rotating the number left by a negative bit count is the same as rotating it right by the negated bit count:\n * `number.rotateLeft(-n) == number.rotateRight(n)`\n *\n * Rotating by a multiple of [ULong.SIZE_BITS] (64) returns the same number, or more generally\n * `number.rotateLeft(n) == number.rotateLeft(n % 64)`\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ WasExperimental ( ExperimentalStdlibApi :: class , ExperimentalUnsignedTypes :: class ) @ kotlin . internal . InlineOnly public inline fun ULong . rotateRight ( bitCount : Int ) : ULong","body":"= toLong ( ) . rotateRight ( bitCount ) . toULong ( )","docstring":"/**\n * Rotates the binary representation of this [ULong] number right by the specified [bitCount] number of bits.\n * The least significant bits pushed out from the right side reenter the number as the most significant bits on the left side.\n *\n * Rotating the number right by a negative bit count is the same as rotating it left by the negated bit count:\n * `number.rotateRight(-n) == number.rotateLeft(n)`\n *\n * Rotating by a multiple of [ULong.SIZE_BITS] (64) returns the same number, or more generally\n * `number.rotateRight(n) == number.rotateRight(n % 64)`\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) @ kotlin . internal . InlineOnly public inline fun UByte . countOneBits ( ) : Int","body":"= toUInt ( ) . countOneBits ( )","docstring":"/**\n * Counts the number of set bits in the binary representation of this [UByte] number.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) @ kotlin . internal . InlineOnly public inline fun UByte . countLeadingZeroBits ( ) : Int","body":"= toByte ( ) . countLeadingZeroBits ( )","docstring":"/**\n * Counts the number of consecutive most significant bits that are zero in the binary representation of this [UByte] number.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) @ kotlin . internal . InlineOnly public inline fun UByte . countTrailingZeroBits ( ) : Int","body":"= toByte ( ) . countTrailingZeroBits ( )","docstring":"/**\n * Counts the number of consecutive least significant bits that are zero in the binary representation of this [UByte] number.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) @ kotlin . internal . InlineOnly public inline fun UByte . takeHighestOneBit ( ) : UByte","body":"= toInt ( ) . takeHighestOneBit ( ) . toUByte ( )","docstring":"/**\n * Returns a number having a single bit set in the position of the most significant set bit of this [UByte] number,\n * or zero, if this number is zero.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) @ kotlin . internal . InlineOnly public inline fun UByte . takeLowestOneBit ( ) : UByte","body":"= toInt ( ) . takeLowestOneBit ( ) . toUByte ( )","docstring":"/**\n * Returns a number having a single bit set in the position of the least significant set bit of this [UByte] number,\n * or zero, if this number is zero.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ WasExperimental ( ExperimentalStdlibApi :: class , ExperimentalUnsignedTypes :: class ) @ kotlin . internal . InlineOnly public inline fun UByte . rotateLeft ( bitCount : Int ) : UByte","body":"= toByte ( ) . rotateLeft ( bitCount ) . toUByte ( )","docstring":"/**\n * Rotates the binary representation of this [UByte] number left by the specified [bitCount] number of bits.\n * The most significant bits pushed out from the left side reenter the number as the least significant bits on the right side.\n *\n * Rotating the number left by a negative bit count is the same as rotating it right by the negated bit count:\n * `number.rotateLeft(-n) == number.rotateRight(n)`\n *\n * Rotating by a multiple of [UByte.SIZE_BITS] (8) returns the same number, or more generally\n * `number.rotateLeft(n) == number.rotateLeft(n % 8)`\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ WasExperimental ( ExperimentalStdlibApi :: class , ExperimentalUnsignedTypes :: class ) @ kotlin . internal . InlineOnly public inline fun UByte . rotateRight ( bitCount : Int ) : UByte","body":"= toByte ( ) . rotateRight ( bitCount ) . toUByte ( )","docstring":"/**\n * Rotates the binary representation of this [UByte] number right by the specified [bitCount] number of bits.\n * The least significant bits pushed out from the right side reenter the number as the most significant bits on the left side.\n *\n * Rotating the number right by a negative bit count is the same as rotating it left by the negated bit count:\n * `number.rotateRight(-n) == number.rotateLeft(n)`\n *\n * Rotating by a multiple of [UByte.SIZE_BITS] (8) returns the same number, or more generally\n * `number.rotateRight(n) == number.rotateRight(n % 8)`\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) @ kotlin . internal . InlineOnly public inline fun UShort . countOneBits ( ) : Int","body":"= toUInt ( ) . countOneBits ( )","docstring":"/**\n * Counts the number of set bits in the binary representation of this [UShort] number.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) @ kotlin . internal . InlineOnly public inline fun UShort . countLeadingZeroBits ( ) : Int","body":"= toShort ( ) . countLeadingZeroBits ( )","docstring":"/**\n * Counts the number of consecutive most significant bits that are zero in the binary representation of this [UShort] number.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) @ kotlin . internal . InlineOnly public inline fun UShort . countTrailingZeroBits ( ) : Int","body":"= toShort ( ) . countTrailingZeroBits ( )","docstring":"/**\n * Counts the number of consecutive least significant bits that are zero in the binary representation of this [UShort] number.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) @ kotlin . internal . InlineOnly public inline fun UShort . takeHighestOneBit ( ) : UShort","body":"= toInt ( ) . takeHighestOneBit ( ) . toUShort ( )","docstring":"/**\n * Returns a number having a single bit set in the position of the most significant set bit of this [UShort] number,\n * or zero, if this number is zero.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ WasExperimental ( ExperimentalUnsignedTypes :: class , ExperimentalStdlibApi :: class ) @ kotlin . internal . InlineOnly public inline fun UShort . takeLowestOneBit ( ) : UShort","body":"= toInt ( ) . takeLowestOneBit ( ) . toUShort ( )","docstring":"/**\n * Returns a number having a single bit set in the position of the least significant set bit of this [UShort] number,\n * or zero, if this number is zero.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ WasExperimental ( ExperimentalStdlibApi :: class , ExperimentalUnsignedTypes :: class ) @ kotlin . internal . InlineOnly public inline fun UShort . rotateLeft ( bitCount : Int ) : UShort","body":"= toShort ( ) . rotateLeft ( bitCount ) . toUShort ( )","docstring":"/**\n * Rotates the binary representation of this [UShort] number left by the specified [bitCount] number of bits.\n * The most significant bits pushed out from the left side reenter the number as the least significant bits on the right side.\n *\n * Rotating the number left by a negative bit count is the same as rotating it right by the negated bit count:\n * `number.rotateLeft(-n) == number.rotateRight(n)`\n *\n * Rotating by a multiple of [UShort.SIZE_BITS] (16) returns the same number, or more generally\n * `number.rotateLeft(n) == number.rotateLeft(n % 16)`\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ WasExperimental ( ExperimentalStdlibApi :: class , ExperimentalUnsignedTypes :: class ) @ kotlin . internal . InlineOnly public inline fun UShort . rotateRight ( bitCount : Int ) : UShort","body":"= toShort ( ) . rotateRight ( bitCount ) . toUShort ( )","docstring":"/**\n * Rotates the binary representation of this [UShort] number right by the specified [bitCount] number of bits.\n * The least significant bits pushed out from the right side reenter the number as the most significant bits on the left side.\n *\n * Rotating the number right by a negative bit count is the same as rotating it left by the negated bit count:\n * `number.rotateRight(-n) == number.rotateLeft(n)`\n *\n * Rotating by a multiple of [UShort.SIZE_BITS] (16) returns the same number, or more generally\n * `number.rotateRight(n) == number.rotateRight(n % 16)`\n */"} {"signature":"fun isValid ( ) : Boolean","body":"{ return substitutor . isValid }","docstring":"/**\n * Checks if the [ResolutionResult] is valid.\n *\n * The [PsiSubstitutor] which is contained inside [ResolutionResult] might become\n * invalidated as it contains [PsiType]s inside\n *\n * @return true if the substitutor is valid, false otherwise.\n */"} {"signature":"private fun resolve ( ) : ResolutionResult","body":"{ while ( true ) { val snapshot = resolutionResult @ Suppress ( \"\" ) when { snapshot != null && snapshot . isValid ( ) -> { return snapshot } else -> { val computedResult = computeResolveResult ( ) if ( ! resolutionResultAtomicFieldUpdater . compareAndSet ( this , snapshot , computedResult ) ) { continue } return computedResult } } } }","docstring":"/**\n * Resolves the current [JavaClassifierType]\n *\n * The code is thread safe and the logic is the following:\n * 1. Try to get a cached resolution result and return it if it's not invalidated\n * 2. Otherwise, resolve the current [JavaClassifierType], update the cache and return the result.\n *\n * @returns [ResolutionResult] to which the [JavaClassifierType] resovled\n */"} {"signature":"fun FirFunctionSymbol < * > . getSingleMatchedExpectForActualOrNull ( ) : FirFunctionSymbol < * > ?","body":"= ( this as FirBasedSymbol < * > ) . getSingleMatchedExpectForActualOrNull ( ) as? FirFunctionSymbol < * >","docstring":"/**\n * @see expectForActual\n */"} {"signature":"fun FirBasedSymbol < * > . getSingleMatchedExpectForActualOrNull ( ) : FirBasedSymbol < * > ?","body":"= expectForActual ? . get ( ExpectActualMatchingCompatibility . MatchedSuccessfully ) ? . singleOrNull ( )","docstring":"/**\n * @see expectForActual\n */"} {"signature":"@ Test fun `Java primitive annotations work` ( )","body":"{ val writerPlugin = TestOutputWriterPlugin ( ) val configuration = dokkaConfiguration { sourceSets { sourceSet { sourceRoots = listOf ( \"\" ) externalDocumentationLinks = listOf ( DokkaConfiguration . ExternalDocumentationLink . jdk ( ) , stdlibExternalDocumentationLink ) } } } testInline ( \"\"\"\"\"\" . trimMargin ( ) , configuration , pluginOverrides = listOf ( writerPlugin ) , cleanupOutput = true ) { documentablesTransformationStage = { module -> val type = module . packages . single ( ) . classlikes . first { it . name == \"\" } . functions . single ( ) . type as GenericTypeConstructor assertEquals ( Annotations . Annotation ( DRI ( \"\" , \"\" ) , emptyMap ( ) ) , type . extra [ Annotations ] ? . directAnnotations ? . values ? . single ( ) ? . single ( ) ) assertEquals ( \"\" , type . dri . toString ( ) ) } } }","docstring":"/**\n * Kotlin Int becomes java int. Java int cannot be annotated in source, but Kotlin Int can be.\n * This is paired with DefaultDescriptorToDocumentableTranslatorTest.`Java primitive annotations work`()\n *\n * This test currently does not do anything because Kotlin.Int currently becomes java.lang.Integer not primitive int\n */"} {"signature":"internal fun < T > Stack < T > . push ( item : T )","body":"= add ( item )","docstring":"/**\n * Pushes item to [Stack]\n * @param item Item to be pushed\n */"} {"signature":"internal fun < T > Stack < T > . pop ( ) : T ?","body":"= if ( isNotEmpty ( ) ) removeAt ( lastIndex ) else null","docstring":"/**\n * Pops (removes and return) last item from [Stack]\n * @return item Last item if [Stack] is not empty, null otherwise\n */"} {"signature":"internal fun < T > Stack < T > . peek ( ) : T ?","body":"= if ( isNotEmpty ( ) ) this [ lastIndex ] else null","docstring":"/**\n * Peeks (return) last item from [Stack]\n * @return item Last item if [Stack] is not empty, null otherwise\n */"} {"signature":"fun usage ( )","body":"{ }","docstring":"/**\n * [Receiver.ext]\n */"} {"signature":"@ Test fun testTheSameValueIsComputedFromDifferentThreads ( )","body":"{ val valueWithPostCompute = ValueWithPostCompute ( key = , calculate = { Thread . currentThread ( ) . name to Unit } , postCompute = { _ , _ , _ -> } ) val results = ConcurrentLinkedQueue < String > ( ) val threads = ( .. ) . map { threadIndex -> thread ( name = \"\" , start = false ) { results . offer ( valueWithPostCompute . getValue ( ) ) } } threads . forEach { it . start ( ) } threads . forEach { it . join ( ) } val resultsList = results . toList ( ) Assertions . assertEquals ( threads . size , results . size ) Assertions . assertTrue ( resultsList . all { it == resultsList [ ] } , \"\" ) }","docstring":"/**\n * Tests the following scenario:\n * - thread `t1` access the cache and executes `calculate()` and then `postCompute()` under a lock hold\n * - while the lock hold by `t1`, `t2` tries to also access the value and waits for the lock to be released by `t1`\n * - t1: during the post compute, some recoverable (e.g., PCE) exception happens inside the `postCompute()` and exception is not saved in the cache and rethrown\n * - t1 releases the lock with the `value` set to `ValueIsNotComputed`\n * - t2 acquires the lock and should try to recalculate the value in this case\n */"} {"signature":"@ Test fun testPCEFromPostCompute ( )","body":"{ for ( i in .. ) { val t1CalledCalculate = CountDownLatch ( ) val t2AccessedTheCache = CountDownLatch ( ) val resultRef = AtomicReference < Any ? > ( null ) val valueWithPostCompute = ValueWithPostCompute ( key = , calculate = { if ( Thread . currentThread ( ) . name == \"\" ) { t1CalledCalculate . countDown ( ) } Thread . currentThread ( ) . name to Unit } , postCompute = { _ , _ , _ -> t2AccessedTheCache . await ( ) if ( Thread . currentThread ( ) . name == \"\" ) { throw ProcessCanceledException ( ) } } ) val t1 = thread ( name = \"\" ) { try { valueWithPostCompute . getValue ( ) } catch ( _ : ProcessCanceledException ) { } } val t2 = thread ( name = \"\" ) { t1CalledCalculate . await ( ) t2AccessedTheCache . countDown ( ) try { resultRef . set ( valueWithPostCompute . getValue ( ) ) } catch ( e : Throwable ) { resultRef . set ( e ) } } t2 . join ( ) t1 . join ( ) when ( val result = resultRef . get ( ) ) { is Throwable -> throw result else -> Assertions . assertEquals ( \"\" , result ) } } }","docstring":"/**\n * Tests the following scenario:\n * - thread `t1` access the cache and executes `calculate()` and then `postCompute()` under a lock hold\n * - while the lock hold by `t1`, `t2` tries to also access the value and waits for the lock to be released by `t1`\n * - t1: during the post compute, some recoverable (e.g., PCE) exception happens inside the `postCompute()` and exception is not saved in the cache and rethrown\n * - t1 releases the lock with the `value` set to `ValueIsNotComputed`\n * - t2 acquires the lock and should try to recalculate the value in this case\n */"} {"signature":"fun coroutineCreation ( ) : StackTraceElement","body":"= Exception ( ) . artificialFrame ( _CREATION :: class . java . simpleName )","docstring":"/**\n * Returns an artificial stack trace element denoting the boundary between coroutine creation and its execution.\n *\n * Appearance of this function in stack traces does not mean that it was called. Instead, it is used as a marker\n * that separates the part of the stack trace with the code executed in a coroutine from the stack trace of the code\n * that launched the coroutine.\n *\n * In earlier versions of kotlinx-coroutines, this was displayed as \"(Coroutine creation stacktrace)\", which caused\n * problems for tooling that processes stack traces: https://github.com/Kotlin/kotlinx.coroutines/issues/2291\n *\n * Note that presence of this marker in a stack trace implies that coroutine creation stack traces were enabled.\n */"} {"signature":"fun coroutineBoundary ( ) : StackTraceElement","body":"= Exception ( ) . artificialFrame ( _BOUNDARY :: class . java . simpleName )","docstring":"/**\n * Returns an artificial stack trace element denoting a coroutine boundary.\n *\n * Appearance of this function in stack traces does not mean that it was called. Instead, when one coroutine invokes\n * another, this is used as a marker in the stack trace to denote where the execution of one coroutine ends and that\n * of another begins.\n *\n * In earlier versions of kotlinx-coroutines, this was displayed as \"(Coroutine boundary)\", which caused\n * problems for tooling that processes stack traces: https://github.com/Kotlin/kotlinx.coroutines/issues/2291\n */"} {"signature":"private fun Throwable . artificialFrame ( name : String ) : StackTraceElement","body":"= with ( stackTrace [ ] ) { StackTraceElement ( ARTIFICIAL_FRAME_PACKAGE_NAME + \"\" + name , \"\" , fileName , lineNumber ) }","docstring":"/**\n * Forms an artificial stack frame with the given class name.\n *\n * It consists of the following parts:\n * 1. The package name, it seems, is needed for the IDE to detect stack trace elements reliably. It is `_COROUTINE` since\n * this is a valid identifier.\n * 2. Class names represents what type of artificial frame this is.\n * 3. The method name is `_`. The methods not being present in class definitions does not seem to affect navigation.\n */"} {"signature":"public fun breaks ( breaks : List < DomainType > ? = null , format : String ? = null )","body":"{ this . breaks = breaks this . format = format }","docstring":"/**\n * Sets legend breaks with formatting.\n *\n * @param breaks list of breaks.\n * @param format format string.\n */"} {"signature":"public fun breaksLabeled ( vararg breaksToLabels : Pair < DomainType , String > )","body":"{ breaks = breaksToLabels . map { it . first } labels = breaksToLabels . map { it . second } }","docstring":"/**\n * Sets legend breaks with labels.\n *\n * @param breaksToLabels list of breaks with corresponding labels.\n */"} {"signature":"public fun breaksLabeled ( breaks : List < DomainType > , labels : List < String > )","body":"{ this . breaks = breaks this . labels = labels }","docstring":"/**\n * Sets legend breaks with labels.\n *\n * @param breaks list of breaks.\n * @param labels list of corresponding labels.\n */"} {"signature":"public operator fun iterator ( ) : ByteIterator","body":"{ return ImmutableBlobIteratorImpl ( this ) }","docstring":"/** Creates an iterator over the elements of the array. */"} {"signature":"@ Suppress ( \"\" ) @ Deprecated ( \"\" ) @ DeprecatedSinceKotlin ( warningSince = \"\" ) @ GCUnsafeCall ( \"\" ) public external fun ImmutableBlob . toByteArray ( startIndex : Int = , endIndex : Int = size ) : ByteArray","body":"@ Suppress ( \"\" ) @ Deprecated ( \"\" ) @ DeprecatedSinceKotlin ( warningSince = \"\" ) @ GCUnsafeCall ( \"\" ) public external fun ImmutableBlob . toByteArray ( startIndex : Int = , endIndex : Int = size ) : ByteArray","docstring":"/**\n * Copies the data from this blob into a new [ByteArray].\n *\n * @param startIndex the beginning (inclusive) of the subrange to copy, 0 by default.\n * @param endIndex the end (exclusive) of the subrange to copy, size of this blob by default.\n */"} {"signature":"@ Suppress ( \"\" ) @ Deprecated ( \"\" ) @ DeprecatedSinceKotlin ( warningSince = \"\" ) @ ExperimentalUnsignedTypes @ GCUnsafeCall ( \"\" ) public external fun ImmutableBlob . toUByteArray ( startIndex : Int = , endIndex : Int = size ) : UByteArray","body":"@ Suppress ( \"\" ) @ Deprecated ( \"\" ) @ DeprecatedSinceKotlin ( warningSince = \"\" ) @ ExperimentalUnsignedTypes @ GCUnsafeCall ( \"\" ) public external fun ImmutableBlob . toUByteArray ( startIndex : Int = , endIndex : Int = size ) : UByteArray","docstring":"/**\n * Copies the data from this blob into a new [UByteArray].\n *\n * @param startIndex the beginning (inclusive) of the subrange to copy, 0 by default.\n * @param endIndex the end (exclusive) of the subrange to copy, size of this blob by default.\n */"} {"signature":"@ Suppress ( \"\" ) @ Deprecated ( \"\" ) @ DeprecatedSinceKotlin ( warningSince = \"\" ) public fun ImmutableBlob . asCPointer ( offset : Int = ) : CPointer < ByteVar >","body":"= interpretCPointer < ByteVar > ( asCPointerImpl ( offset ) ) ! !","docstring":"/**\n * Returns stable C pointer to data at certain [offset], useful as a way to pass resource\n * to C APIs.\n *\n * `ImmutableBlob` is deprecated since Kotlin 1.9. It is recommended to use `ByteArray` instead.\n * To get a stable C pointer to `ByteArray` data the array needs to be pinned first.\n * ```\n * byteArray.usePinned {\n * val cpointer = it.addressOf(offset)\n * // use the stable C pointer\n * }\n * ```\n * @see kotlinx.cinterop.CPointer\n */"} {"signature":"@ Suppress ( \"\" ) @ Deprecated ( \"\" ) @ DeprecatedSinceKotlin ( warningSince = \"\" ) public fun ImmutableBlob . asUCPointer ( offset : Int = ) : CPointer < UByteVar >","body":"= interpretCPointer < UByteVar > ( asCPointerImpl ( offset ) ) ! !","docstring":"/**\n * Returns stable C pointer to data at certain [offset], useful as a way to pass resource\n * to C APIs.\n *\n * `ImmutableBlob` is deprecated since Kotlin 1.9. It is recommended to use `ByteArray` instead.\n * To get a stable C pointer to `ByteArray` data the array needs to be pinned first.\n * ```\n * byteArray.usePinned {\n * val cpointer = it.addressOf(offset)\n * // use the stable C pointer\n * }\n * ```\n * @see kotlinx.cinterop.CPointer\n */"} {"signature":"@ Suppress ( \"\" ) @ Deprecated ( \"\" , ReplaceWith ( \"\" ) ) @ DeprecatedSinceKotlin ( warningSince = \"\" ) @ TypedIntrinsic ( IntrinsicType . IMMUTABLE_BLOB ) public external fun immutableBlobOf ( vararg elements : Short ) : ImmutableBlob","body":"@ Suppress ( \"\" ) @ Deprecated ( \"\" , ReplaceWith ( \"\" ) ) @ DeprecatedSinceKotlin ( warningSince = \"\" ) @ TypedIntrinsic ( IntrinsicType . IMMUTABLE_BLOB ) public external fun immutableBlobOf ( vararg elements : Short ) : ImmutableBlob","docstring":"/**\n * Creates [ImmutableBlob] out of compile-time constant data.\n *\n * This method accepts values of [Short] type in range `0x00..0xff`, other values are prohibited.\n *\n * One element still represent one byte in the output data.\n * This is the only way to create ImmutableBlob for now.\n */"} {"signature":"public fun ColumnSet < * > . colGroups ( filter : Predicate < ColumnGroup < * > > = { true } ) : TransformableColumnSet < AnyRow >","body":"= columnGroupsInternal ( filter )","docstring":"/**\n * @include [CommonColGroupsDocs]\n * @set [CommonColGroupsDocs.ExampleArg]\n *\n * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`(\"my\") }.`[colGroups][ColumnSet.colGroups]`() }`\n *\n * `// NOTE: This can be shortened to just:`\n *\n * `df.`[select][DataFrame.select]` { `[colGroups][ColumnsSelectionDsl.colGroups]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`(\"my\") } }`\n */"} {"signature":"public fun ColumnsSelectionDsl < * > . colGroups ( filter : Predicate < ColumnGroup < * > > = { true } ) : TransformableColumnSet < AnyRow >","body":"= asSingleColumn ( ) . columnGroupsInternal ( filter )","docstring":"/**\n * @include [CommonColGroupsDocs]\n * @set [CommonColGroupsDocs.ExampleArg]\n *\n * `df.`[select][DataFrame.select]` { `[colGroups][ColumnsSelectionDsl.colGroups]`() }`\n *\n * `df.`[select][DataFrame.select]` { `[colGroups][ColumnsSelectionDsl.colGroups]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`(\"my\") } }`\n */"} {"signature":"public fun SingleColumn < DataRow < * > > . colGroups ( filter : Predicate < ColumnGroup < * > > = { true } ) : TransformableColumnSet < AnyRow >","body":"= this . ensureIsColumnGroup ( ) . columnGroupsInternal ( filter )","docstring":"/**\n * @include [CommonColGroupsDocs]\n * @set [CommonColGroupsDocs.ExampleArg]\n *\n * `df.`[select][DataFrame.select]` { myColGroup.`[colGroups][SingleColumn.colGroups]`() }`\n *\n * `df.`[select][DataFrame.select]` { myColGroup.`[colGroups][SingleColumn.colGroups]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`(\"my\") } }`\n */"} {"signature":"public fun String . colGroups ( filter : Predicate < ColumnGroup < * > > = { true } ) : TransformableColumnSet < AnyRow >","body":"= columnGroup ( this ) . colGroups ( filter )","docstring":"/**\n * @include [CommonColGroupsDocs]\n * @set [CommonColGroupsDocs.ExampleArg]\n *\n * `df.`[select][DataFrame.select]` { \"myColGroup\".`[colGroups][String.colGroups]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`(\"my\") } }`\n *\n * `df.`[select][DataFrame.select]` { \"myColGroup\".`[colGroups][String.colGroups]`() }`\n */"} {"signature":"public fun KProperty < * > . colGroups ( filter : Predicate < ColumnGroup < * > > = { true } ) : TransformableColumnSet < AnyRow >","body":"= columnGroup ( this ) . colGroups ( filter )","docstring":"/**\n * @include [CommonColGroupsDocs]\n * @set [CommonColGroupsDocs.ExampleArg]\n *\n * `df.`[select][DataFrame.select]` { `[colGroup][ColumnsSelectionDsl.colGroup]`(Type::myColGroup).`[colGroups][SingleColumn.colGroups]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`(\"my\") } }`\n *\n * `df.`[select][DataFrame.select]` { DataSchemaType::myColGroup.`[colGroups][KProperty.colGroups]`() }`\n */"} {"signature":"public fun ColumnPath . colGroups ( filter : Predicate < ColumnGroup < * > > = { true } ) : TransformableColumnSet < AnyRow >","body":"= columnGroup ( this ) . colGroups ( filter )","docstring":"/**\n * @include [CommonColGroupsDocs]\n * @set [CommonColGroupsDocs.ExampleArg]\n *\n * `df.`[select][DataFrame.select]` { \"pathTo\"[\"myGroupCol\"].`[colGroups][ColumnPath.colGroups]`() }`\n */"} {"signature":"@ Suppress ( \"\" ) internal fun ColumnsResolver < * > . columnGroupsInternal ( filter : ( ColumnGroup < * > ) -> Boolean ) : TransformableColumnSet < AnyRow >","body":"= colsInternal { it . isColumnGroup ( ) && filter ( it . asColumnGroup ( ) ) } as TransformableColumnSet < AnyRow >","docstring":"/**\n * Returns a TransformableColumnSet containing the column groups that satisfy the given filter.\n *\n * @param filter The filter function to apply on each column group. Must accept a ColumnGroup object and return a Boolean.\n * @return A [TransformableColumnSet] containing the column groups that satisfy the filter.\n */"} {"signature":"internal fun IrStatementsBuilder < * > . createCacheableChildSerializersFactory ( cacheProperty : IrProperty ? , cacheableSerializers : List < Boolean > , containingClassProducer : ( ) -> IrClass ) : ( Int ) -> IrExpression ?","body":"{ cacheProperty ? : return { null } val variable = irTemporary ( irInvoke ( irGetObject ( containingClassProducer ( ) ) , cacheProperty . getter ! ! . symbol ) , \"\" ) return { index : Int -> if ( cacheableSerializers [ index ] ) { irInvoke ( irGet ( variable ) , compilerContext . arrayValueGetter . symbol , irInt ( index ) ) } else { null } } }","docstring":"/**\n * Factory to getting cached serializers via variable.\n * Must be used only in one place because for each factory creates one variable.\n *\n * Class from [containingClassProducer] used only if [cacheProperty] is not null.\n */"} {"signature":"fun normalizePath ( path : String ) : String","body":"{ var start = var separator = false if ( isWindows ) { if ( path . startsWith ( \"\" ) ) { start = separator = true } else if ( path . startsWith ( \"\" ) ) { return normalizeTail ( , path , false ) } } for ( i in start until path . length ) { val c = path [ i ] if ( c == '' ) { if ( separator ) { return normalizeTail ( i , path , true ) } separator = true } else if ( c == '' ) { return normalizeTail ( i , path , separator ) } else { separator = false } } return path }","docstring":"/**\n * converts back slashes to forward slashes\n * removes double slashes inside the path, e.g. \"x/y//z\" => \"x/y/z\"\n *\n * Converted from com.intellij.openapi.util.io.FileUtil.normalize\n */"} {"signature":"fun getFields ( llvm : CodegenLlvmHelpers ) : List < FieldInfo >","body":"= getFieldsInternal ( llvm ) . map { fieldInfo -> val mappedField = fieldInfo . irField ? . let { context . mapping . lateInitFieldToNullableField [ it ] ? : it } if ( mappedField == fieldInfo . irField ) fieldInfo else mappedField ! ! . toFieldInfo ( llvm ) }","docstring":"/**\n * All fields of the class instance.\n * The order respects the class hierarchy, i.e. a class [fields] contains superclass [fields] as a prefix.\n */"} {"signature":"fun getDeclaredFields ( llvm : CodegenLlvmHelpers ) : List < FieldInfo >","body":"{ val outerThisField = if ( irClass . isInner ) context . innerClassesSupport . getOuterThisField ( irClass ) else null val moduleDeserializer = context . irLinker . getCachedDeclarationModuleDeserializer ( irClass ) if ( moduleDeserializer != null ) return moduleDeserializer . deserializeClassFields ( irClass , outerThisField ? . toFieldInfo ( llvm ) ) val declarations = irClass . declarations . toMutableList ( ) outerThisField ? . let { if ( ! declarations . contains ( it ) ) declarations += it } return declarations . mapNotNull { when ( it ) { is IrField -> it . takeIf { it . isReal && ! it . isStatic } ? . toFieldInfo ( llvm ) is IrProperty -> it . takeIf { it . isReal } ? . backingField ? . takeIf { ! it . isStatic } ? . toFieldInfo ( llvm ) else -> null } } }","docstring":"/**\n * Fields declared in the class.\n */"} {"signature":"fun IrSimpleFunction . getLoweredVersion ( )","body":"= when { isSuspend -> this . getOrCreateFunctionWithContinuationStub ( context ) else -> this }","docstring":"/**\n * Normally, function should be already replaced. But if the function come from LazyIr, it can be not replaced.\n */"} {"signature":"open fun generate ( )","body":"{ val frameMapAtStart = codegen . frameMap . mark ( ) prepareConfiguration ( ) val hasElse = expression . elseExpression != null defaultLabel = if ( hasElse || ! isStatement || isExhaustive ) elseLabel else endLabel generateSubjectValue ( ) generateSubjectValueToIndex ( ) val beginLabel = Label ( ) v . mark ( beginLabel ) generateSwitchInstructionByTransitionsTable ( ) generateEntries ( ) if ( ! hasElse && ( ! isStatement || isExhaustive ) ) { v . visitLabel ( elseLabel ) codegen . putUnitInstanceOntoStackForNonExhaustiveWhen ( expression , isStatement ) } codegen . markLineNumber ( expression , isStatement ) v . mark ( endLabel ) frameMapAtStart . dropTo ( ) subjectVariableDescriptor ? . let { v . visitLocalVariable ( it . name . asString ( ) , subjectType . descriptor , null , beginLabel , endLabel , subjectLocal ) } }","docstring":"/**\n * Generates bytecode for entire when expression\n */"} {"signature":"private fun prepareConfiguration ( )","body":"{ for ( entry in expression . entries ) { val entryLabel = Label ( ) for ( constant in switchCodegenProvider . getConstantsFromEntry ( entry ) ) { if ( constant is NullValue || constant == null ) continue processConstant ( constant , entryLabel , entry ) } if ( entry . isElse ) { elseLabel = entryLabel } entryLabels . add ( entryLabel ) } }","docstring":"/**\n * Sets up transitionsTable and maybe something else needed in a special case\n * Behaviour may be changed by overriding processConstant\n */"} {"signature":"private fun generateSubjectValue ( )","body":"{ if ( subjectVariable != null ) { val mySubjectVariable = bindingContext [ BindingContext . VARIABLE , subjectVariable ] ? : throw AssertionError ( \"\" ) subjectLocal = codegen . frameMap . enter ( mySubjectVariable , subjectType ) codegen . visitProperty ( subjectVariable , null ) StackValue . local ( subjectLocal , subjectType , subjectKotlinType ) . put ( subjectType , subjectKotlinType , codegen . v ) subjectVariableDescriptor = mySubjectVariable } else { codegen . gen ( subjectExpression , subjectType , subjectKotlinType ) subjectVariableDescriptor = null } }","docstring":"/**\n * Generates subject value on top of the stack.\n * If the subject is a variable, it's stored and loaded.\n */"} {"signature":"protected abstract fun generateSubjectValueToIndex ( )","body":"protected abstract fun generateSubjectValueToIndex ( )","docstring":"/**\n * Given a subject value on stack (after [generateSubjectValue]),\n * produces int value to be used in switch.\n */"} {"signature":"public suspend fun < S , T : S > Flow < T > . reduce ( operation : suspend ( accumulator : S , value : T ) -> S ) : S","body":"{ var accumulator : Any ? = NULL collect { value -> accumulator = if ( accumulator !== NULL ) { @ Suppress ( \"\" ) operation ( accumulator as S , value ) } else { value } } if ( accumulator === NULL ) throw NoSuchElementException ( \"\" ) @ Suppress ( \"\" ) return accumulator as S }","docstring":"/**\n * Accumulates value starting with the first element and applying [operation] to current accumulator value and each element.\n * Throws [NoSuchElementException] if flow was empty.\n */"} {"signature":"public suspend inline fun < T , R > Flow < T > . fold ( initial : R , crossinline operation : suspend ( acc : R , value : T ) -> R ) : R","body":"{ var accumulator = initial collect { value -> accumulator = operation ( accumulator , value ) } return accumulator }","docstring":"/**\n * Accumulates value starting with [initial] value and applying [operation] current accumulator value and each element\n */"} {"signature":"public suspend fun < T > Flow < T > . single ( ) : T","body":"{ var result : Any ? = NULL collect { value -> require ( result === NULL ) { \"\" } result = value } if ( result === NULL ) throw NoSuchElementException ( \"\" ) return result as T }","docstring":"/**\n * The terminal operator that awaits for one and only one value to be emitted.\n * Throws [NoSuchElementException] for empty flow and [IllegalArgumentException] for flow\n * that contains more than one element.\n */"} {"signature":"public suspend fun < T > Flow < T > . singleOrNull ( ) : T ?","body":"{ var result : Any ? = NULL collectWhile { if ( result === NULL ) { result = it true } else { result = NULL false } } return if ( result === NULL ) null else result as T }","docstring":"/**\n * The terminal operator that awaits for one and only one value to be emitted.\n * Returns the single value or `null`, if the flow was empty or emitted more than one value.\n */"} {"signature":"public suspend fun < T > Flow < T > . first ( ) : T","body":"{ var result : Any ? = NULL collectWhile { result = it false } if ( result === NULL ) throw NoSuchElementException ( \"\" ) return result as T }","docstring":"/**\n * The terminal operator that returns the first element emitted by the flow and then cancels flow's collection.\n * Throws [NoSuchElementException] if the flow was empty.\n */"} {"signature":"public suspend fun < T > Flow < T > . first ( predicate : suspend ( T ) -> Boolean ) : T","body":"{ var result : Any ? = NULL collectWhile { if ( predicate ( it ) ) { result = it false } else { true } } if ( result === NULL ) throw NoSuchElementException ( \"\" ) return result as T }","docstring":"/**\n * The terminal operator that returns the first element emitted by the flow matching the given [predicate] and then cancels flow's collection.\n * Throws [NoSuchElementException] if the flow has not contained elements matching the [predicate].\n */"} {"signature":"public suspend fun < T > Flow < T > . firstOrNull ( ) : T ?","body":"{ var result : T ? = null collectWhile { result = it false } return result }","docstring":"/**\n * The terminal operator that returns the first element emitted by the flow and then cancels flow's collection.\n * Returns `null` if the flow was empty.\n */"} {"signature":"public suspend fun < T > Flow < T > . firstOrNull ( predicate : suspend ( T ) -> Boolean ) : T ?","body":"{ var result : T ? = null collectWhile { if ( predicate ( it ) ) { result = it false } else { true } } return result }","docstring":"/**\n * The terminal operator that returns the first element emitted by the flow matching the given [predicate] and then cancels flow's collection.\n * Returns `null` if the flow did not contain an element matching the [predicate].\n */"} {"signature":"public suspend fun < T > Flow < T > . last ( ) : T","body":"{ var result : Any ? = NULL collect { result = it } if ( result === NULL ) throw NoSuchElementException ( \"\" ) return result as T }","docstring":"/**\n * The terminal operator that returns the last element emitted by the flow.\n *\n * Throws [NoSuchElementException] if the flow was empty.\n */"} {"signature":"public suspend fun < T > Flow < T > . lastOrNull ( ) : T ?","body":"{ var result : T ? = null collect { result = it } return result }","docstring":"/**\n * The terminal operator that returns the last element emitted by the flow or `null` if the flow was empty.\n */"} {"signature":"public fun < T : Number , D : Dimension > MultiArray < T , D > . toSortedSet ( ) : java . util . SortedSet < T >","body":"{ return toCollection ( java . util . TreeSet ( ) ) }","docstring":"/**\n * Returns a [SortedSet][java.util.SortedSet] of all elements.\n */"} {"signature":"public fun < T , D : Dimension > MultiArray < T , D > . toSortedSet ( comparator : Comparator < in T > ) : java . util . SortedSet < T >","body":"{ return toCollection ( java . util . TreeSet ( comparator ) ) }","docstring":"/**\n * Returns a [SortedSet][java.util.SortedSet] of all elements.\n *\n * Elements in the set returned are sorted according to the given [comparator].\n */"} {"signature":"public abstract fun provideExtensionsFor ( module : KtModule ) : List < KtResolveExtension >","body":"public abstract fun provideExtensionsFor ( module : KtModule ) : List < KtResolveExtension >","docstring":"/**\n * Provides a list of [KtResolveExtension]s for a given [KtModule].\n *\n * Should not perform any heavy analysis and the generation of the actual files. All file generation should be performed only in [KtResolveExtensionFile.buildFileText].\n *\n * Implementations should consider caching the results, so the subsequent invocations should be performed instantly.\n *\n * Implementation cannot use the Kotlin resolve inside, as this function is called during session initialization, so Analysis API access is forbidden.\n */"} {"signature":"internal expect fun ensurePlatformExceptionHandlerLoaded ( callback : CoroutineExceptionHandler )","body":"internal expect fun ensurePlatformExceptionHandlerLoaded ( callback : CoroutineExceptionHandler )","docstring":"/**\n * Ensures that the given [callback] is present in the [platformExceptionHandlers] list.\n */"} {"signature":"internal expect fun propagateExceptionFinalResort ( exception : Throwable )","body":"internal expect fun propagateExceptionFinalResort ( exception : Throwable )","docstring":"/**\n * The platform-dependent global exception handler, used so that the exception is logged at least *somewhere*.\n */"} {"signature":"internal fun handleUncaughtCoroutineException ( context : CoroutineContext , exception : Throwable )","body":"{ for ( handler in platformExceptionHandlers ) { try { handler . handleException ( context , exception ) } catch ( _ : ExceptionSuccessfullyProcessed ) { return } catch ( t : Throwable ) { propagateExceptionFinalResort ( handlerException ( exception , t ) ) } } try { exception . addSuppressed ( DiagnosticCoroutineContextException ( context ) ) } catch ( e : Throwable ) { } propagateExceptionFinalResort ( exception ) }","docstring":"/**\n * Deal with exceptions that happened in coroutines and weren't programmatically dealt with.\n *\n * First, it notifies every [CoroutineExceptionHandler] in the [platformExceptionHandlers] list.\n * If one of them throws [ExceptionSuccessfullyProcessed], it means that that handler believes that the exception was\n * dealt with sufficiently well and doesn't need any further processing.\n * Otherwise, the platform-dependent global exception handler is also invoked.\n */"} {"signature":"public fun getFloatArray ( result : R , index : Int ) : FloatArray","body":"public fun getFloatArray ( result : R , index : Int ) : FloatArray","docstring":"/**\n * Returns the output at [index] as a [FloatArray].\n */"} {"signature":"public fun getLongArray ( result : R , index : Int ) : LongArray","body":"public fun getLongArray ( result : R , index : Int ) : LongArray","docstring":"/**\n * Returns the output at [index] as a [LongArray].\n */"} {"signature":"abstract fun isVisible ( receiver : ReceiverValue ? , what : DeclarationDescriptorWithVisibility , from : DeclarationDescriptor , useSpecialRulesForPrivateSealedConstructors : Boolean ) : Boolean","body":"abstract fun isVisible ( receiver : ReceiverValue ? , what : DeclarationDescriptorWithVisibility , from : DeclarationDescriptor , useSpecialRulesForPrivateSealedConstructors : Boolean ) : Boolean","docstring":"/**\n * @param receiver can be used to determine callee accessibility for some special receiver value\n *\n * 'null'-value basically means that receiver is absent in current call\n *\n * In case if it's needed to perform basic checks ignoring ones considering receiver (e.g. when checks happen beyond any call),\n * special value Visibilities.ALWAYS_SUITABLE_RECEIVER should be used.\n * If it's needed to determine whether visibility accepts any receiver, Visibilities.IRRELEVANT_RECEIVER should be used.\n *\n * NB: Currently Visibilities.IRRELEVANT_RECEIVER has the same effect as 'null'\n *\n * Also it's important that implementation that take receiver into account do aware about these special values.\n */"} {"signature":"abstract fun mustCheckInImports ( ) : Boolean","body":"abstract fun mustCheckInImports ( ) : Boolean","docstring":"/**\n * True, if it makes sense to check this visibility in imports and not import inaccessible declarations with such visibility.\n * Hint: return true, if this visibility can be checked on file's level.\n * Examples:\n * it returns false for PROTECTED because protected members of classes can be imported to be used in subclasses of their containers,\n * so when we are looking at the import, we don't know whether it is legal somewhere in this file or not.\n * it returns true for INTERNAL, because an internal declaration is either visible everywhere in a file, or invisible everywhere in the same file.\n * it returns true for PRIVATE, because there's no point in importing privates: they are inaccessible unless their short name is\n * already available without an import\n */"} {"signature":"fun compareTo ( visibility : DescriptorVisibility ) : Int ?","body":"{ return delegate . compareTo ( visibility . delegate ) }","docstring":"/**\n * @return null if the answer is unknown\n */"} {"signature":"fun convertExpression ( expression : LighterASTNode , errorReason : String ) : FirElement","body":"{ return when ( expression . tokenType ) { LAMBDA_EXPRESSION -> convertLambdaExpression ( expression ) BINARY_EXPRESSION -> convertBinaryExpression ( expression ) BINARY_WITH_TYPE -> convertBinaryWithTypeRHSExpression ( expression ) { this . getOperationSymbol ( ) . toFirOperation ( ) } IS_EXPRESSION -> convertBinaryWithTypeRHSExpression ( expression ) { if ( this == \"\" ) FirOperation . IS else FirOperation . NOT_IS } LABELED_EXPRESSION -> convertLabeledExpression ( expression ) PREFIX_EXPRESSION , POSTFIX_EXPRESSION -> convertUnaryExpression ( expression ) ANNOTATED_EXPRESSION -> convertAnnotatedExpression ( expression ) CLASS_LITERAL_EXPRESSION -> convertClassLiteralExpression ( expression ) CALLABLE_REFERENCE_EXPRESSION -> convertCallableReferenceExpression ( expression ) in QUALIFIED_ACCESS -> convertQualifiedExpression ( expression ) CALL_EXPRESSION -> convertCallExpression ( expression ) WHEN -> convertWhenExpression ( expression ) ARRAY_ACCESS_EXPRESSION -> convertArrayAccessExpression ( expression ) COLLECTION_LITERAL_EXPRESSION -> convertCollectionLiteralExpression ( expression ) STRING_TEMPLATE -> convertStringTemplate ( expression ) is KtConstantExpressionElementType -> convertConstantExpression ( expression ) REFERENCE_EXPRESSION -> convertSimpleNameExpression ( expression ) DO_WHILE -> convertDoWhile ( expression ) WHILE -> convertWhile ( expression ) FOR -> convertFor ( expression ) TRY -> convertTryExpression ( expression ) IF -> convertIfExpression ( expression ) BREAK , CONTINUE -> convertLoopJump ( expression ) RETURN -> convertReturn ( expression ) THROW -> convertThrow ( expression ) PARENTHESIZED -> { val content = expression . getExpressionInParentheses ( ) context . forwardLabelUsagePermission ( expression , content ) getAsFirExpression ( content , \"\" ) } PROPERTY_DELEGATE , INDICES , CONDITION , LOOP_RANGE -> getAsFirExpression ( expression . getChildExpression ( ) , errorReason ) THIS_EXPRESSION -> convertThisExpression ( expression ) SUPER_EXPRESSION -> convertSuperExpression ( expression ) OBJECT_LITERAL -> declarationBuilder . convertObjectLiteral ( expression ) FUN -> declarationBuilder . convertFunctionDeclaration ( expression ) DESTRUCTURING_DECLARATION -> declarationBuilder . convertDestructingDeclaration ( expression ) . toFirDestructingDeclaration ( this , baseModuleData ) else -> buildErrorExpression ( expression . toFirSourceElement ( KtFakeSourceElementKind . ErrorTypeRef ) , ConeSimpleDiagnostic ( errorReason , DiagnosticKind . ExpressionExpected ) ) } }","docstring":"/***** EXPRESSIONS *****/"} {"signature":"private fun convertLambdaExpression ( lambdaExpression : LighterASTNode ) : FirExpression","body":"{ val valueParameterList = mutableListOf < ValueParameter > ( ) var block : LighterASTNode ? = null var hasArrow = false val functionSymbol = FirAnonymousFunctionSymbol ( ) lambdaExpression . getChildNodesByType ( FUNCTION_LITERAL ) . first ( ) . forEachChildren { when ( it . tokenType ) { VALUE_PARAMETER_LIST -> valueParameterList += declarationBuilder . convertValueParameters ( it , functionSymbol , ValueParameterDeclaration . LAMBDA ) BLOCK -> block = it ARROW -> hasArrow = true } } val expressionSource = lambdaExpression . toFirSourceElement ( ) val target : FirFunctionTarget val anonymousFunction = buildAnonymousFunction { source = expressionSource moduleData = baseModuleData origin = FirDeclarationOrigin . Source returnTypeRef = implicitType receiverParameter = expressionSource . asReceiverParameter ( ) symbol = functionSymbol isLambda = true hasExplicitParameterList = hasArrow label = context . getLastLabel ( lambdaExpression ) ? : context . calleeNamesForLambda . lastOrNull ( ) ? . let { buildLabel { source = expressionSource . fakeElement ( KtFakeSourceElementKind . GeneratedLambdaLabel ) name = it . asString ( ) } } target = FirFunctionTarget ( labelName = label ? . name , isLambda = true ) context . firFunctionTargets += target val destructuringStatements = mutableListOf < FirStatement > ( ) for ( valueParameter in valueParameterList ) { val multiDeclaration = valueParameter . destructuringDeclaration valueParameters += if ( multiDeclaration != null ) { val name = SpecialNames . DESTRUCT val multiParameter = buildValueParameter { source = valueParameter . firValueParameter . source containingFunctionSymbol = functionSymbol moduleData = baseModuleData origin = FirDeclarationOrigin . Source returnTypeRef = valueParameter . firValueParameter . returnTypeRef this . name = name symbol = FirValueParameterSymbol ( name ) defaultValue = null isCrossinline = false isNoinline = false isVararg = false } addDestructuringStatements ( destructuringStatements , baseModuleData , multiDeclaration , multiParameter , tmpVariable = false , forceLocal = true , ) multiParameter } else { valueParameter . firValueParameter } } body = withForcedLocalContext { if ( block != null ) { val kind = runIf ( destructuringStatements . isNotEmpty ( ) ) { KtFakeSourceElementKind . LambdaDestructuringBlock } val bodyBlock = declarationBuilder . convertBlockExpressionWithoutBuilding ( block ! ! , kind ) . apply { statements . firstOrNull ( ) ? . let { if ( it . isContractBlockFirCheck ( ) ) { this@buildAnonymousFunction . contractDescription = it . toLegacyRawContractDescription ( ) statements [ ] = FirContractCallBlock ( it ) } } if ( statements . isEmpty ( ) ) { statements . add ( buildReturnExpression { source = expressionSource . fakeElement ( KtFakeSourceElementKind . ImplicitReturn . FromExpressionBody ) this . target = target result = buildUnitExpression { source = expressionSource . fakeElement ( KtFakeSourceElementKind . ImplicitUnit . LambdaCoercion ) } } ) } } . build ( ) if ( destructuringStatements . isNotEmpty ( ) ) { buildBlock { source = bodyBlock . source ? . realElement ( ) statements . addAll ( destructuringStatements ) statements . add ( bodyBlock ) } } else { bodyBlock } } else { buildSingleExpressionBlock ( buildErrorExpression ( null , ConeSyntaxDiagnostic ( \"\" ) ) ) } } context . firFunctionTargets . removeLast ( ) } . also { target . bind ( it ) } return buildAnonymousFunctionExpression { source = expressionSource this . anonymousFunction = anonymousFunction } }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseFunctionLiteral\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitLambdaExpression\n */"} {"signature":"private fun convertBinaryExpression ( binaryExpression : LighterASTNode ) : FirStatement","body":"{ var isLeftArgument = true lateinit var operationTokenName : String var leftArgNode : LighterASTNode ? = null var rightArg : LighterASTNode ? = null var operationReferenceSource : KtLightSourceElement ? = null binaryExpression . forEachChildren { when ( it . tokenType ) { OPERATION_REFERENCE -> { isLeftArgument = false operationTokenName = it . asText operationReferenceSource = it . toFirSourceElement ( ) } else -> if ( it . isExpression ( ) ) { if ( isLeftArgument ) { leftArgNode = it } else { rightArg = it } } } } val baseSource = binaryExpression . toFirSourceElement ( ) val operationToken = operationTokenName . getOperationSymbol ( ) if ( operationToken == IDENTIFIER ) { context . calleeNamesForLambda += operationTokenName . nameAsSafeName ( ) } else { context . calleeNamesForLambda += null } val rightArgAsFir = if ( rightArg != null ) getAsFirExpression < FirExpression > ( rightArg , \"\" ) else buildErrorExpression ( null , ConeSyntaxDiagnostic ( \"\" ) ) val leftArgAsFir = getAsFirExpression < FirExpression > ( leftArgNode , \"\" ) context . calleeNamesForLambda . removeLast ( ) when ( operationToken ) { ELVIS -> return leftArgAsFir . generateNotNullOrOther ( rightArgAsFir , baseSource ) ANDAND , OROR -> return leftArgAsFir . generateLazyLogicalOperation ( rightArgAsFir , operationToken == ANDAND , baseSource ) in OperatorConventions . IN_OPERATIONS -> return rightArgAsFir . generateContainsOperation ( leftArgAsFir , operationToken == NOT_IN , baseSource , operationReferenceSource ) in OperatorConventions . COMPARISON_OPERATIONS -> return leftArgAsFir . generateComparisonExpression ( rightArgAsFir , operationToken , baseSource , operationReferenceSource ) } val conventionCallName = operationToken . toBinaryName ( ) return if ( conventionCallName != null || operationToken == IDENTIFIER ) { buildFunctionCall { source = binaryExpression . toFirSourceElement ( ) calleeReference = buildSimpleNamedReference { source = operationReferenceSource ? : this@buildFunctionCall . source name = conventionCallName ? : operationTokenName . nameAsSafeName ( ) } explicitReceiver = leftArgAsFir argumentList = buildUnaryArgumentList ( rightArgAsFir ) origin = if ( conventionCallName != null ) FirFunctionCallOrigin . Operator else FirFunctionCallOrigin . Infix } } else { val firOperation = operationToken . toFirOperation ( ) if ( firOperation in FirOperation . ASSIGNMENTS ) { return leftArgNode . generateAssignment ( binaryExpression . toFirSourceElement ( ) , leftArgNode ? . toFirSourceElement ( ) , rightArgAsFir , firOperation , leftArgAsFir . annotations , rightArg , ) { getAsFirExpression < FirExpression > ( this , \"\" , sourceWhenInvalidExpression = binaryExpression , isValidExpression = { ! it . isStatementLikeExpression || it . isArraySet } , ) } } else { buildEqualityOperatorCall { source = binaryExpression . toFirSourceElement ( ) operation = firOperation argumentList = buildBinaryArgumentList ( leftArgAsFir , rightArgAsFir ) } } } }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseBinaryExpression\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitBinaryExpression\n */"} {"signature":"private fun convertBinaryWithTypeRHSExpression ( binaryExpression : LighterASTNode , toFirOperation : String . ( ) -> FirOperation ) : FirTypeOperatorCall","body":"{ lateinit var operationTokenName : String var leftArgAsFir : FirExpression ? = null lateinit var firType : FirTypeRef binaryExpression . forEachChildren { when ( it . tokenType ) { OPERATION_REFERENCE -> operationTokenName = it . asText TYPE_REFERENCE -> firType = declarationBuilder . convertType ( it ) else -> if ( it . isExpression ( ) ) leftArgAsFir = getAsFirExpression ( it , \"\" ) } } return buildTypeOperatorCall { source = binaryExpression . toFirSourceElement ( ) operation = operationTokenName . toFirOperation ( ) conversionTypeRef = firType argumentList = buildUnaryArgumentList ( leftArgAsFir ? : buildErrorExpression ( null , ConeSyntaxDiagnostic ( \"\" ) ) ) } }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.Precedence.parseRightHandSide\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitBinaryWithTypeRHSExpression\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitIsExpression\n */"} {"signature":"private fun convertLabeledExpression ( labeledExpression : LighterASTNode ) : FirElement","body":"{ var firExpression : FirElement ? = null var labelSource : KtSourceElement ? = null var forbiddenLabelKind : ForbiddenLabelKind ? = null val isRepetitiveLabel = labeledExpression . getLabeledExpression ( ) ? . tokenType == LABELED_EXPRESSION labeledExpression . forEachChildren { context . setNewLabelUserNode ( it ) when ( it . tokenType ) { LABEL_QUALIFIER -> { val name = it . asText . dropLast ( ) labelSource = it . getChildNodesByType ( LABEL ) . single ( ) . toFirSourceElement ( ) context . addNewLabel ( buildLabel ( name , labelSource ! ! ) ) forbiddenLabelKind = getForbiddenLabelKind ( name , isRepetitiveLabel ) } BLOCK -> firExpression = declarationBuilder . convertBlock ( it ) PROPERTY -> firExpression = declarationBuilder . convertPropertyDeclaration ( it ) else -> if ( it . isExpression ( ) ) firExpression = getAsFirStatement ( it ) } } context . dropLastLabel ( ) return buildExpressionHandlingErrors ( firExpression , labeledExpression . toFirSourceElement ( ) , forbiddenLabelKind , labelSource ) }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseLabeledExpression\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitLabeledExpression\n */"} {"signature":"private fun convertUnaryExpression ( unaryExpression : LighterASTNode ) : FirExpression","body":"{ lateinit var operationTokenName : String var argument : LighterASTNode ? = null var operationReference : LighterASTNode ? = null unaryExpression . forEachChildren { when ( it . tokenType ) { OPERATION_REFERENCE -> { operationReference = it operationTokenName = it . asText } else -> if ( it . isExpression ( ) ) argument = it } } val operationToken = operationTokenName . getOperationSymbol ( ) val conventionCallName = operationToken . toUnaryName ( ) return when { operationToken == EXCLEXCL -> { buildCheckNotNullCall { source = unaryExpression . toFirSourceElement ( ) argumentList = buildUnaryArgumentList ( getAsFirExpression < FirExpression > ( argument , \"\" ) ) } } conventionCallName != null -> { if ( operationToken in OperatorConventions . INCREMENT_OPERATIONS ) { return generateIncrementOrDecrementBlock ( unaryExpression , operationReference , argument , callName = conventionCallName , prefix = unaryExpression . tokenType == PREFIX_EXPRESSION ) { getAsFirExpression ( this ) } } val receiver = getAsFirExpression < FirExpression > ( argument , \"\" ) convertUnaryPlusMinusCallOnIntegerLiteralIfNecessary ( unaryExpression , receiver , operationToken ) ? . let { return it } buildFunctionCall { source = unaryExpression . toFirSourceElement ( ) calleeReference = buildSimpleNamedReference { source = operationReference ? . toFirSourceElement ( ) ? : this@buildFunctionCall . source name = conventionCallName } explicitReceiver = receiver origin = FirFunctionCallOrigin . Operator } } else -> throw IllegalStateException ( \"\" ) } }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parsePostfixExpression\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parsePrefixExpression\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitUnaryExpression\n */"} {"signature":"private fun convertAnnotatedExpression ( annotatedExpression : LighterASTNode ) : FirElement","body":"{ var firExpression : FirElement ? = null val firAnnotationList = mutableListOf < FirAnnotation > ( ) annotatedExpression . forEachChildren { when ( it . tokenType ) { ANNOTATION -> firAnnotationList += declarationBuilder . convertAnnotation ( it ) ANNOTATION_ENTRY -> firAnnotationList += declarationBuilder . convertAnnotationEntry ( it ) BLOCK -> firExpression = declarationBuilder . convertBlockExpression ( it ) else -> if ( it . isExpression ( ) ) { context . forwardLabelUsagePermission ( annotatedExpression , it ) firExpression = getAsFirStatement ( it ) } } } val result = firExpression ? : buildErrorExpression ( null , ConeNotAnnotationContainer ( \"\" ) ) require ( result is FirAnnotationContainer ) result . replaceAnnotations ( result . annotations . smartPlus ( firAnnotationList ) ) return result }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parsePrefixExpression\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitAnnotatedExpression\n */"} {"signature":"private fun convertClassLiteralExpression ( classLiteralExpression : LighterASTNode ) : FirExpression","body":"{ var firReceiverExpression : FirExpression ? = null classLiteralExpression . forEachChildren { if ( it . isExpression ( ) ) firReceiverExpression = getAsFirExpression ( it , \"\" ) } val classLiteralSource = classLiteralExpression . toFirSourceElement ( ) return buildGetClassCall { source = classLiteralSource argumentList = buildUnaryArgumentList ( firReceiverExpression ? : buildErrorExpression ( classLiteralSource , ConeUnsupportedClassLiteralsWithEmptyLhs ) ) } }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseDoubleColonSuffix\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitClassLiteralExpression\n */"} {"signature":"private fun convertCallableReferenceExpression ( callableReferenceExpression : LighterASTNode ) : FirExpression","body":"{ var isReceiver = true var hasQuestionMarkAtLHS = false var firReceiverExpression : FirExpression ? = null lateinit var namedReference : FirNamedReference callableReferenceExpression . forEachChildren { when ( it . tokenType ) { COLONCOLON -> isReceiver = false QUEST -> hasQuestionMarkAtLHS = true else -> if ( it . isExpression ( ) ) { if ( isReceiver ) { firReceiverExpression = getAsFirExpression ( it , \"\" ) } else { namedReference = createSimpleNamedReference ( it . toFirSourceElement ( ) , it ) } } } } return buildCallableReferenceAccess { source = callableReferenceExpression . toFirSourceElement ( ) calleeReference = namedReference explicitReceiver = firReceiverExpression this . hasQuestionMarkAtLHS = hasQuestionMarkAtLHS } }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseDoubleColonSuffix\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitCallableReferenceExpression\n */"} {"signature":"private fun convertQualifiedExpression ( dotQualifiedExpression : LighterASTNode ) : FirExpression","body":"{ var isSelector = false var isSafe = false var firSelector : FirExpression ? = null var firReceiver : FirExpression ? = null dotQualifiedExpression . forEachChildren { when ( val tokenType = it . tokenType ) { DOT -> isSelector = true SAFE_ACCESS -> { isSafe = true isSelector = true } else -> { val isEffectiveSelector = isSelector && tokenType != TokenType . ERROR_ELEMENT val firExpression = getAsFirExpression < FirExpression > ( it , \"\" ) if ( isEffectiveSelector ) { val callExpressionCallee = if ( tokenType == CALL_EXPRESSION ) it . getFirstChildExpressionUnwrapped ( ) else null firSelector = if ( tokenType is KtNameReferenceExpressionElementType || ( tokenType == CALL_EXPRESSION && callExpressionCallee ? . tokenType != LAMBDA_EXPRESSION ) ) { firExpression } else { buildErrorExpression { source = callExpressionCallee ? . toFirSourceElement ( ) ? : it . toFirSourceElement ( ) diagnostic = ConeSimpleDiagnostic ( \"\" , if ( callExpressionCallee == null ) DiagnosticKind . IllegalSelector else DiagnosticKind . NoReceiverAllowed ) expression = firExpression } } } else { firReceiver = firExpression } } } } var result = firSelector ( firSelector as? FirQualifiedAccessExpression ) ? . let { if ( isSafe ) { @ OptIn ( FirImplementationDetail :: class ) it . replaceSource ( dotQualifiedExpression . toFirSourceElement ( KtFakeSourceElementKind . DesugaredSafeCallExpression ) ) return it . createSafeCall ( firReceiver ! ! , dotQualifiedExpression . toFirSourceElement ( ) ) } result = convertFirSelector ( it , dotQualifiedExpression . toFirSourceElement ( ) , firReceiver ! ! ) } val receiver = firReceiver if ( receiver != null ) { ( firSelector as? FirErrorExpression ) ? . let { errorExpression -> return buildQualifiedErrorAccessExpression { this . receiver = receiver this . selector = errorExpression source = dotQualifiedExpression . toFirSourceElement ( ) diagnostic = ConeSyntaxDiagnostic ( \"\" ) } } } return result ? : buildErrorExpression { source = dotQualifiedExpression . toFirSourceElement ( ) diagnostic = ConeSyntaxDiagnostic ( \"\" ) expression = firReceiver } }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parsePostfixExpression\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitQualifiedExpression\n */"} {"signature":"private fun convertCallExpression ( callSuffix : LighterASTNode ) : FirExpression","body":"{ var name : String ? = null val firTypeArguments = mutableListOf < FirTypeProjection > ( ) val valueArguments = mutableListOf < LighterASTNode > ( ) var additionalArgument : FirExpression ? = null var hasArguments = false var superNode : LighterASTNode ? = null callSuffix . forEachChildren { child -> fun process ( node : LighterASTNode ) { when ( node . tokenType ) { REFERENCE_EXPRESSION -> { name = node . asText } SUPER_EXPRESSION -> { superNode = node } PARENTHESIZED -> if ( node . tokenType != TokenType . ERROR_ELEMENT ) { additionalArgument = getAsFirExpression ( node . getExpressionInParentheses ( ) , \"\" ) } TYPE_ARGUMENT_LIST -> { firTypeArguments += declarationBuilder . convertTypeArguments ( node , allowedUnderscoredTypeArgument = true ) } VALUE_ARGUMENT_LIST , LAMBDA_ARGUMENT -> { hasArguments = true valueArguments += node } else -> if ( node . tokenType != TokenType . ERROR_ELEMENT ) { additionalArgument = getAsFirExpression ( node , \"\" ) } } } process ( child ) } val source = callSuffix . toFirSourceElement ( ) val ( calleeReference , explicitReceiver , isImplicitInvoke ) = when { name != null -> CalleeAndReceiver ( buildSimpleNamedReference { this . source = callSuffix . getFirstChildExpressionUnwrapped ( ) ? . toFirSourceElement ( ) ? : source this . name = name . nameAsSafeName ( ) } ) superNode != null || ( additionalArgument as? FirResolvable ) ? . calleeReference is FirSuperReference -> { CalleeAndReceiver ( buildErrorNamedReference { this . source = superNode ? . toFirSourceElement ( ) ? : ( additionalArgument as? FirResolvable ) ? . calleeReference ? . source diagnostic = ConeSimpleDiagnostic ( \"\" , DiagnosticKind . SuperNotAllowed ) } ) } additionalArgument != null -> { CalleeAndReceiver ( buildSimpleNamedReference { this . source = source this . name = OperatorNameConventions . INVOKE } , additionalArgument ! ! , isImplicitInvoke = true ) } else -> CalleeAndReceiver ( buildErrorNamedReference { this . source = source diagnostic = ConeSyntaxDiagnostic ( \"\" ) } ) } val builder : FirQualifiedAccessExpressionBuilder = if ( hasArguments ) { val builder = if ( isImplicitInvoke ) FirImplicitInvokeCallBuilder ( ) else FirFunctionCallBuilder ( ) builder . apply { this . source = source this . calleeReference = calleeReference context . calleeNamesForLambda += calleeReference . name this . extractArgumentsFrom ( valueArguments . flatMap { convertValueArguments ( it ) } ) context . calleeNamesForLambda . removeLast ( ) } } else { FirPropertyAccessExpressionBuilder ( ) . apply { this . source = source this . calleeReference = calleeReference } } return builder . apply { this . explicitReceiver = explicitReceiver typeArguments += firTypeArguments } . build ( ) }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseCallSuffix\n */"} {"signature":"private fun convertStringTemplate ( stringTemplate : LighterASTNode ) : FirExpression","body":"{ return stringTemplate . getChildrenAsArray ( ) . toInterpolatingCall ( stringTemplate ) { convertShortOrLongStringTemplate ( it ) } }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseStringTemplate\n */"} {"signature":"private fun convertConstantExpression ( constantExpression : LighterASTNode ) : FirExpression","body":"{ return generateConstantExpressionByLiteral ( constantExpression ) }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseLiteralConstant\n */"} {"signature":"private fun convertWhenExpression ( whenExpression : LighterASTNode ) : FirExpression","body":"{ var subjectExpression : FirExpression ? = null var subjectVariable : FirVariable ? = null val whenEntryNodes = mutableListOf < LighterASTNode > ( ) val whenEntries = mutableListOf < WhenEntry > ( ) whenExpression . forEachChildren { when ( it . tokenType ) { PROPERTY -> subjectVariable = ( declarationBuilder . convertPropertyDeclaration ( it ) as FirVariable ) . let { variable -> buildProperty { source = it . toFirSourceElement ( ) origin = FirDeclarationOrigin . Source moduleData = baseModuleData returnTypeRef = variable . returnTypeRef name = variable . name initializer = variable . initializer isVar = false symbol = FirPropertySymbol ( variable . name ) isLocal = true status = FirDeclarationStatusImpl ( Visibilities . Local , Modality . FINAL ) annotations += variable . annotations } } DESTRUCTURING_DECLARATION -> subjectExpression = getAsFirExpression ( it , \"\" ) WHEN_ENTRY -> whenEntryNodes += it else -> if ( it . isExpression ( ) ) subjectExpression = getAsFirExpression ( it , \"\" ) } } subjectExpression = subjectVariable ? . initializer ? : subjectExpression val hasSubject = subjectExpression != null @ OptIn ( FirContractViolation :: class ) val subject = FirExpressionRef < FirWhenExpression > ( ) var shouldBind = hasSubject whenEntryNodes . mapTo ( whenEntries ) { convertWhenEntry ( it , subject , hasSubject ) } return buildWhenExpression { source = whenExpression . toFirSourceElement ( ) this . subject = subjectExpression this . subjectVariable = subjectVariable usedAsExpression = whenExpression . usedAsExpression for ( entry in whenEntries ) { shouldBind = shouldBind || entry . shouldBindSubject val branch = entry . firBlock val entrySource = entry . node . toFirSourceElement ( ) branches += if ( ! entry . isElse ) { if ( hasSubject ) { val firCondition = entry . toFirWhenCondition ( ) buildWhenBranch { source = entrySource condition = firCondition result = branch } } else { val firCondition = entry . toFirWhenConditionWithoutSubject ( ) buildWhenBranch { source = entrySource condition = firCondition result = branch } } } else { buildWhenBranch { source = entrySource condition = buildElseIfTrueCondition ( ) result = branch } } } } . also { if ( shouldBind ) { subject . bind ( it ) } } }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseWhen\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitWhenExpression\n */"} {"signature":"private fun convertWhenEntry ( whenEntry : LighterASTNode , whenRefWithSubject : FirExpressionRef < FirWhenExpression > , hasSubject : Boolean , ) : WhenEntry","body":"{ var isElse = false var firBlock : FirBlock = buildEmptyExpressionBlock ( ) val conditions = mutableListOf < FirExpression > ( ) var shouldBindSubject = false whenEntry . forEachChildren { when ( it . tokenType ) { WHEN_CONDITION_EXPRESSION -> conditions += convertWhenConditionExpression ( it , whenRefWithSubject . takeIf { hasSubject } ) WHEN_CONDITION_IN_RANGE -> { val ( condition , shouldBind ) = convertWhenConditionInRange ( it , whenRefWithSubject , hasSubject ) conditions += condition shouldBindSubject = shouldBindSubject || shouldBind } WHEN_CONDITION_IS_PATTERN -> { val ( condition , shouldBind ) = convertWhenConditionIsPattern ( it , whenRefWithSubject , hasSubject ) conditions += condition shouldBindSubject = shouldBindSubject || shouldBind } ELSE_KEYWORD -> isElse = true BLOCK -> firBlock = declarationBuilder . convertBlock ( it ) else -> if ( it . isExpression ( ) ) firBlock = declarationBuilder . convertBlock ( it ) } } return WhenEntry ( conditions , firBlock , whenEntry , isElse , shouldBindSubject ) }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseWhenEntry\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseWhenEntryNotElse\n */"} {"signature":"private fun convertArrayAccessExpression ( arrayAccess : LighterASTNode ) : FirExpression","body":"{ var firExpression : FirExpression ? = null val indices : MutableList < FirExpression > = mutableListOf ( ) arrayAccess . forEachChildren { when ( it . tokenType ) { INDICES -> indices += convertIndices ( it ) else -> if ( it . isExpression ( ) ) firExpression = getAsFirExpression ( it , \"\" ) } } val getArgument = context . arraySetArgument . remove ( arrayAccess ) return buildFunctionCall { val isGet = getArgument == null source = ( if ( isGet ) arrayAccess else arrayAccess . getParent ( ) ! ! ) . toFirSourceElement ( ) calleeReference = buildSimpleNamedReference { source = arrayAccess . toFirSourceElement ( ) . fakeElement ( KtFakeSourceElementKind . ArrayAccessNameReference ) name = if ( isGet ) OperatorNameConventions . GET else OperatorNameConventions . SET } explicitReceiver = firExpression ? : buildErrorExpression ( null , ConeSyntaxDiagnostic ( \"\" ) ) argumentList = buildArgumentList { arguments += indices getArgument ? . let { arguments += it } } origin = FirFunctionCallOrigin . Operator } . pullUpSafeCallIfNecessary ( ) }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseArrayAccess\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitArrayAccessExpression\n */"} {"signature":"private fun convertCollectionLiteralExpression ( expression : LighterASTNode ) : FirExpression","body":"{ val firExpressionList = mutableListOf < FirExpression > ( ) expression . forEachChildren { if ( it . isExpression ( ) ) firExpressionList += getAsFirExpression < FirExpression > ( it , \"\" ) } return buildArrayLiteral { source = expression . toFirSourceElement ( ) argumentList = buildArgumentList { arguments += firExpressionList } } }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseCollectionLiteralExpression\n */"} {"signature":"private fun convertIndices ( indices : LighterASTNode ) : List < FirExpression >","body":"{ val firExpressionList : MutableList < FirExpression > = mutableListOf ( ) indices . forEachChildren { if ( it . isExpression ( ) ) firExpressionList += getAsFirExpression < FirExpression > ( it , \"\" ) } return firExpressionList }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseAsCollectionLiteralExpression\n */"} {"signature":"private fun convertSimpleNameExpression ( referenceExpression : LighterASTNode ) : FirQualifiedAccessExpression","body":"{ val nameSource = referenceExpression . toFirSourceElement ( ) val referenceSourceElement = if ( nameSource . kind is KtFakeSourceElementKind ) { nameSource } else { nameSource . fakeElement ( KtFakeSourceElementKind . ReferenceInAtomicQualifiedAccess ) } return buildPropertyAccessExpression { val rawText = referenceExpression . asText if ( rawText . isUnderscore ) { nonFatalDiagnostics . add ( ConeUnderscoreUsageWithoutBackticks ( nameSource ) ) } source = nameSource calleeReference = createSimpleNamedReference ( referenceSourceElement , referenceExpression ) } }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseSimpleNameExpression\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitSimpleNameExpression\n */"} {"signature":"private fun convertDoWhile ( doWhileLoop : LighterASTNode ) : FirElement","body":"{ var block : LighterASTNode ? = null var firCondition : FirExpression ? = null val target : FirLoopTarget return FirDoWhileLoopBuilder ( ) . apply { source = doWhileLoop . toFirSourceElement ( ) target = prepareTarget ( doWhileLoop ) doWhileLoop . forEachChildren { when ( it . tokenType ) { BODY -> block = it CONDITION -> firCondition = getAsFirExpression ( it , \"\" ) } } condition = firCondition ? : buildErrorExpression ( null , ConeSyntaxDiagnostic ( \"\" ) ) } . configure ( target ) { convertLoopBody ( block ) } }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseDoWhile\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitDoWhileExpression\n */"} {"signature":"private fun convertWhile ( whileLoop : LighterASTNode ) : FirElement","body":"{ var block : LighterASTNode ? = null var firCondition : FirExpression ? = null whileLoop . forEachChildren { when ( it . tokenType ) { BODY -> block = it CONDITION -> firCondition = getAsFirExpression ( it , \"\" ) } } val target : FirLoopTarget return FirWhileLoopBuilder ( ) . apply { source = whileLoop . toFirSourceElement ( ) condition = firCondition ? : buildErrorExpression ( null , ConeSyntaxDiagnostic ( \"\" ) ) target = prepareTarget ( whileLoop ) } . configure ( target ) { convertLoopBody ( block ) } }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseWhile\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitWhileExpression\n */"} {"signature":"private fun convertFor ( forLoop : LighterASTNode ) : FirElement","body":"{ var parameter : ValueParameter ? = null var rangeExpression : FirExpression ? = null var blockNode : LighterASTNode ? = null forLoop . forEachChildren { when ( it . tokenType ) { VALUE_PARAMETER -> parameter = declarationBuilder . convertValueParameter ( it , null , ValueParameterDeclaration . FOR_LOOP ) LOOP_RANGE -> rangeExpression = getAsFirExpression ( it , \"\" ) BODY -> blockNode = it } } val calculatedRangeExpression = rangeExpression ? : buildErrorExpression ( null , ConeSyntaxDiagnostic ( \"\" ) ) val fakeSource = forLoop . toFirSourceElement ( KtFakeSourceElementKind . DesugaredForLoop ) val rangeSource = calculatedRangeExpression . source ? . fakeElement ( KtFakeSourceElementKind . DesugaredForLoop ) ? : fakeSource val target : FirLoopTarget return buildBlock { source = fakeSource val iteratorVal = generateTemporaryVariable ( baseModuleData , rangeSource , SpecialNames . ITERATOR , buildFunctionCall { source = rangeSource calleeReference = buildSimpleNamedReference { source = rangeSource name = OperatorNameConventions . ITERATOR } explicitReceiver = calculatedRangeExpression origin = FirFunctionCallOrigin . Operator } ) statements += iteratorVal statements += FirWhileLoopBuilder ( ) . apply { source = fakeSource condition = buildFunctionCall { source = rangeSource calleeReference = buildSimpleNamedReference { source = rangeSource name = OperatorNameConventions . HAS_NEXT } explicitReceiver = generateResolvedAccessExpression ( rangeSource , iteratorVal ) origin = FirFunctionCallOrigin . Operator } target = prepareTarget ( forLoop ) } . configure ( target ) { buildBlock block @ { source = blockNode ? . toFirSourceElement ( ) val valueParameter = parameter ? : return@block val multiDeclaration = valueParameter . destructuringDeclaration val firLoopParameter = generateTemporaryVariable ( baseModuleData , valueParameter . source , if ( multiDeclaration != null ) SpecialNames . DESTRUCT else valueParameter . name , buildFunctionCall { source = rangeSource calleeReference = buildSimpleNamedReference { source = rangeSource name = OperatorNameConventions . NEXT } explicitReceiver = generateResolvedAccessExpression ( rangeSource , iteratorVal ) origin = FirFunctionCallOrigin . Operator } , valueParameter . returnTypeRef , extractedAnnotations = valueParameter . annotations ) if ( multiDeclaration != null ) { addDestructuringStatements ( statements , baseModuleData , multiDeclaration , firLoopParameter , tmpVariable = true , forceLocal = true , ) } else { statements . add ( firLoopParameter ) } statements += convertLoopBody ( blockNode ) } } } }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseFor\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitForExpression\n */"} {"signature":"private fun convertLoopBody ( body : LighterASTNode ? ) : FirBlock","body":"{ return convertLoopOrIfBody ( body ) ? : buildEmptyExpressionBlock ( ) }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseLoopBody\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.toFirBlock\n */"} {"signature":"private fun convertTryExpression ( tryExpression : LighterASTNode ) : FirExpression","body":"{ lateinit var tryBlock : FirBlock val catchClauses = mutableListOf < Triple < ValueParameter ? , FirBlock , KtLightSourceElement > > ( ) var finallyBlock : FirBlock ? = null tryExpression . forEachChildren { when ( it . tokenType ) { BLOCK -> tryBlock = declarationBuilder . convertBlock ( it ) CATCH -> convertCatchClause ( it ) ? . also { oneClause -> catchClauses += oneClause } FINALLY -> finallyBlock = convertFinally ( it ) } } return buildTryExpression { source = tryExpression . toFirSourceElement ( ) this . tryBlock = tryBlock this . finallyBlock = finallyBlock for ( ( parameter , block , clauseSource ) in catchClauses ) { if ( parameter == null ) continue catches += buildCatch { this . parameter = buildProperty { source = parameter . source moduleData = baseModuleData origin = FirDeclarationOrigin . Source returnTypeRef = parameter . returnTypeRef isVar = false status = FirResolvedDeclarationStatusImpl ( Visibilities . Local , Modality . FINAL , EffectiveVisibility . Local ) isLocal = true this . name = parameter . name symbol = FirPropertySymbol ( CallableId ( name ) ) annotations += parameter . annotations } . also { it . isCatchParameter = true } this . block = block this . source = clauseSource } } } }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseTry\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitTryExpression\n */"} {"signature":"private fun convertCatchClause ( catchClause : LighterASTNode ) : Triple < ValueParameter ? , FirBlock , KtLightSourceElement > ?","body":"{ var valueParameter : ValueParameter ? = null var blockNode : LighterASTNode ? = null catchClause . forEachChildren { when ( it . tokenType ) { VALUE_PARAMETER_LIST -> valueParameter = declarationBuilder . convertValueParameters ( it , FirAnonymousFunctionSymbol ( ) , ValueParameterDeclaration . CATCH ) . firstOrNull ( ) ? : return null BLOCK -> blockNode = it } } return Triple ( valueParameter , declarationBuilder . convertBlock ( blockNode ) , catchClause . toFirSourceElement ( ) ) }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseTry\n */"} {"signature":"private fun convertFinally ( finallyExpression : LighterASTNode ) : FirBlock","body":"{ var blockNode : LighterASTNode ? = null finallyExpression . forEachChildren { when ( it . tokenType ) { BLOCK -> blockNode = it } } return declarationBuilder . convertBlock ( blockNode ) }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseTry\n */"} {"signature":"private fun convertIfExpression ( ifExpression : LighterASTNode ) : FirExpression","body":"{ return buildWhenExpression { source = ifExpression . toFirSourceElement ( ) with ( parseIfExpression ( ifExpression ) ) { val trueBranch = convertLoopBody ( thenBlock ) branches += buildWhenBranch { source = firCondition ? . source condition = firCondition ? : buildErrorExpression ( null , ConeSyntaxDiagnostic ( \"\" ) ) result = trueBranch } if ( elseBlock != null ) { val elseBranch = convertLoopOrIfBody ( elseBlock ) if ( elseBranch != null ) { branches += buildWhenBranch { source = elseBlock . toFirSourceElement ( ) condition = buildElseIfTrueCondition ( ) result = elseBranch } } } } usedAsExpression = ifExpression . usedAsExpression } }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseIf\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitIfExpression\n */"} {"signature":"private fun convertLoopJump ( jump : LighterASTNode ) : FirExpression","body":"{ var isBreak = true jump . forEachChildren { when ( it . tokenType ) { CONTINUE_KEYWORD -> isBreak = false } } val jumpBuilder = if ( isBreak ) FirBreakExpressionBuilder ( ) else FirContinueExpressionBuilder ( ) val sourceElement = jump . toFirSourceElement ( ) return jumpBuilder . apply { source = sourceElement } . bindLabel ( jump ) . build ( ) }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseJump\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitBreakExpression\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitContinueExpression\n */"} {"signature":"private fun convertReturn ( returnExpression : LighterASTNode ) : FirExpression","body":"{ var labelName : String ? = null var firExpression : FirExpression ? = null returnExpression . forEachChildren { when ( it . tokenType ) { LABEL_QUALIFIER -> labelName = it . getAsStringWithoutBacktick ( ) . replace ( \"\" , \"\" ) else -> if ( it . isExpression ( ) ) firExpression = getAsFirExpression ( it , \"\" ) } } val calculatedFirExpression = firExpression ? : buildUnitExpression { source = returnExpression . toFirSourceElement ( KtFakeSourceElementKind . ImplicitUnit . Return ) } return calculatedFirExpression . toReturn ( baseSource = returnExpression . toFirSourceElement ( ) , labelName = labelName , fromKtReturnExpression = true ) }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseReturn\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitReturnExpression\n */"} {"signature":"private fun convertThrow ( throwExpression : LighterASTNode ) : FirExpression","body":"{ var firExpression : FirExpression ? = null throwExpression . forEachChildren { if ( it . isExpression ( ) ) firExpression = getAsFirExpression ( it , \"\" ) } return buildThrowExpression { source = throwExpression . toFirSourceElement ( ) exception = firExpression ? : buildErrorExpression ( null , ConeSyntaxDiagnostic ( \"\" ) ) } }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseThrow\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitThrowExpression\n */"} {"signature":"private fun convertThisExpression ( thisExpression : LighterASTNode ) : FirQualifiedAccessExpression","body":"{ val label : String ? = thisExpression . getLabelName ( ) return buildThisReceiverExpression { val sourceElement = thisExpression . toFirSourceElement ( ) source = sourceElement calleeReference = buildExplicitThisReference { labelName = label source = sourceElement . fakeElement ( KtFakeSourceElementKind . ReferenceInAtomicQualifiedAccess ) } } }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseThisExpression\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitThisExpression\n */"} {"signature":"private fun convertSuperExpression ( superExpression : LighterASTNode ) : FirQualifiedAccessExpression","body":"{ val label : String ? = superExpression . getLabelName ( ) var superTypeRef : FirTypeRef = implicitType superExpression . forEachChildren { when ( it . tokenType ) { TYPE_REFERENCE -> superTypeRef = declarationBuilder . convertType ( it ) } } return buildPropertyAccessExpression { val sourceElement = superExpression . toFirSourceElement ( ) source = sourceElement calleeReference = buildExplicitSuperReference { labelName = label this . superTypeRef = superTypeRef source = sourceElement . fakeElement ( KtFakeSourceElementKind . ReferenceInAtomicQualifiedAccess ) } } }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseSuperExpression\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitSuperExpression\n */"} {"signature":"fun convertValueArguments ( valueArguments : LighterASTNode ) : List < FirExpression >","body":"{ return valueArguments . forEachChildrenReturnList { node , container -> when ( node . tokenType ) { VALUE_ARGUMENT -> container += convertValueArgument ( node ) LAMBDA_EXPRESSION , LABELED_EXPRESSION , ANNOTATED_EXPRESSION , -> container += getAsFirExpression < FirAnonymousFunctionExpression > ( node ) . apply { @ OptIn ( RawFirApi :: class ) replaceIsTrailingLambda ( newIsTrailingLambda = true ) } } } }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseValueArgumentList\n */"} {"signature":"private fun convertValueArgument ( valueArgument : LighterASTNode ) : FirExpression","body":"{ var identifier : String ? = null var isSpread = false var firExpression : FirExpression ? = null valueArgument . forEachChildren { when ( it . tokenType ) { VALUE_ARGUMENT_NAME -> identifier = it . asText MUL -> isSpread = true STRING_TEMPLATE -> firExpression = convertStringTemplate ( it ) is KtConstantExpressionElementType -> firExpression = convertConstantExpression ( it ) else -> if ( it . isExpression ( ) ) firExpression = getAsFirExpression ( it , \"\" ) } } val calculatedFirExpression = firExpression ? : buildErrorExpression ( null , ConeSyntaxDiagnostic ( \"\" ) ) return when { identifier != null -> buildNamedArgumentExpression { source = valueArgument . toFirSourceElement ( ) expression = calculatedFirExpression this . isSpread = isSpread name = identifier . nameAsSafeName ( ) } isSpread -> buildSpreadArgumentExpression { source = valueArgument . toFirSourceElement ( ) expression = calculatedFirExpression } else -> calculatedFirExpression } }","docstring":"/**\n * @see org.jetbrains.kotlin.parsing.KotlinExpressionParsing.parseValueArgument\n * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.toFirExpression(org.jetbrains.kotlin.psi.ValueArgument)\n */"} {"signature":"fun excludeUnused ( headerName : String ? ) : Boolean","body":"fun excludeUnused ( headerName : String ? ) : Boolean","docstring":"/**\n * Whether unused declarations from given header should be excluded.\n *\n * @param headerName header path relative to the appropriate include path element (e.g. `time.h` or `curl/curl.h`),\n * or `null` for builtin declarations.\n */"} {"signature":"fun excludeAll ( headerId : HeaderId ) : Boolean","body":"fun excludeAll ( headerId : HeaderId ) : Boolean","docstring":"/**\n * Whether all declarations from this header should be excluded.\n *\n * Note: the declarations from such headers can be actually present in the internal representation,\n * but not included into the root collections.\n */"} {"signature":"fun buildNativeIndex ( library : NativeLibrary , verbose : Boolean ) : IndexerResult","body":"= buildNativeIndexImpl ( library , verbose )","docstring":"/**\n * Retrieves the definitions from given C header file using given compiler arguments (e.g. defines).\n */"} {"signature":"public fun ColumnSet < * > . colsOfKind ( kind : ColumnKind , vararg others : ColumnKind , filter : ColumnFilter < * > = { true } , ) : TransformableColumnSet < * >","body":"= columnsOfKindInternal ( kinds = headPlusArray ( kind , others ) . toSet ( ) , filter = filter )","docstring":"/**\n * @include [CommonColsOfKindDocs]\n * @set [CommonColsOfKindDocs.ExampleArg]\n *\n * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`(\"my\") }.`[colsOfKind][ColumnSet.colsOfKind]`(`[Value][ColumnKind.Value]`, `[Frame][ColumnKind.Frame]`) }`\n *\n * `// NOTE: This can be shortened to just:`\n *\n * `df.`[select][DataFrame.select]` { `[colsOfKind][ColumnsSelectionDsl.colsOfKind]`(`[Value][ColumnKind.Value]`, `[Frame][ColumnKind.Frame]`) { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`(\"my\") } }`\n */"} {"signature":"public fun ColumnsSelectionDsl < * > . colsOfKind ( kind : ColumnKind , vararg others : ColumnKind , filter : ColumnFilter < * > = { true } , ) : TransformableColumnSet < * >","body":"= asSingleColumn ( ) . columnsOfKindInternal ( kinds = headPlusArray ( kind , others ) . toSet ( ) , filter = filter )","docstring":"/**\n * @include [CommonColsOfKindDocs]\n * @set [CommonColsOfKindDocs.ExampleArg]\n *\n * `df.`[select][DataFrame.select]` { `[colsOfKind][ColumnsSelectionDsl.colsOfKind]`(`[Value][ColumnKind.Value]`, `[Frame][ColumnKind.Frame]`) { it.`[name][ColumnReference.name]`.`[startsWith][String.startsWith]`(\"my\") } }`\n */"} {"signature":"public fun SingleColumn < DataRow < * > > . colsOfKind ( kind : ColumnKind , vararg others : ColumnKind , filter : ColumnFilter < * > = { true } , ) : TransformableColumnSet < * >","body":"= this . ensureIsColumnGroup ( ) . columnsOfKindInternal ( kinds = headPlusArray ( kind , others ) . toSet ( ) , filter = filter )","docstring":"/**\n * @include [CommonColsOfKindDocs]\n * @set [CommonColsOfKindDocs.ExampleArg]\n *\n * `df.`[select][DataFrame.select]` { myColumnGroup.`[colsOfKind][SingleColumn.colsOfKind]`(`[Value][ColumnKind.Value]`, `[Frame][ColumnKind.Frame]`) }`\n */"} {"signature":"public fun String . colsOfKind ( kind : ColumnKind , vararg others : ColumnKind , filter : ColumnFilter < * > = { true } , ) : TransformableColumnSet < * >","body":"= columnGroup ( this ) . colsOfKind ( kind , * others , filter = filter )","docstring":"/**\n * @include [CommonColsOfKindDocs]\n * @set [CommonColsOfKindDocs.ExampleArg]\n *\n * `df.`[select][DataFrame.select]` { \"myColumnGroup\".`[colsOfKind][SingleColumn.colsOfKind]`(`[Value][ColumnKind.Value]`, `[Frame][ColumnKind.Frame]`) }`\n */"} {"signature":"public fun KProperty < * > . colsOfKind ( kind : ColumnKind , vararg others : ColumnKind , filter : ColumnFilter < * > = { true } , ) : TransformableColumnSet < * >","body":"= columnGroup ( this ) . colsOfKind ( kind , * others , filter = filter )","docstring":"/**\n * @include [CommonColsOfKindDocs]\n * @set [CommonColsOfKindDocs.ExampleArg]\n *\n * `df.`[select][DataFrame.select]` { Type::myColumnGroup.`[colsOfKind][KProperty.colsOfKind]`(`[Value][ColumnKind.Value]`, `[Frame][ColumnKind.Frame]`) }`\n */"} {"signature":"public fun ColumnPath . colsOfKind ( kind : ColumnKind , vararg others : ColumnKind , filter : ColumnFilter < * > = { true } , ) : TransformableColumnSet < * >","body":"= columnGroup ( this ) . colsOfKind ( kind , * others , filter = filter )","docstring":"/**\n * @include [CommonColsOfKindDocs]\n * @set [CommonColsOfKindDocs.ExampleArg]\n *\n * `df.`[select][DataFrame.select]` { \"pathTo\"[\"myColumnGroup\"].`[colsOfKind][ColumnPath.colsOfKind]`(`[Value][ColumnKind.Value]`, `[Frame][ColumnKind.Frame]`) }`\n */"} {"signature":"internal fun ColumnsResolver < * > . columnsOfKindInternal ( kinds : Set < ColumnKind > , filter : ColumnFilter < * > , ) : TransformableColumnSet < * >","body":"= colsInternal { it . kind ( ) in kinds && filter ( it ) }","docstring":"/**\n * Returns a TransformableColumnSet containing the columns of given kind(s) that satisfy the given filter.\n *\n * @param filter The filter function to apply on each column. Must accept a ColumnWithPath object and return a Boolean.\n * @return A [TransformableColumnSet] containing the columns of given kinds that satisfy the filter.\n */"} {"signature":"fun Project . checkExpectedGradlePropertyValues ( )","body":"{ val expectSuffix = \"\" val expectKeys = properties . keys . filter { it . endsWith ( expectSuffix ) } val issues = expectKeys . mapNotNull { expectKey -> val actualKey = expectKey . removeSuffix ( expectSuffix ) val expectedValue = properties [ expectKey ] ? . toString ( ) ? : return@mapNotNull null if ( ! properties . containsKey ( actualKey ) ) return@mapNotNull MissingProperty ( actualKey , expectedValue ) val actualValue = properties [ actualKey ] . toString ( ) if ( expectedValue != actualValue ) return@mapNotNull UnexpectedPropertyValue ( actualKey , expectedValue , actualValue ) null } . toSet ( ) if ( issues . isEmpty ( ) ) { return } val unexpectedPropertyValues = issues . filterIsInstance < UnexpectedPropertyValue > ( ) val missingProperties = issues . filterIsInstance < MissingProperty > ( ) throw IllegalArgumentException ( buildString { if ( unexpectedPropertyValues . isNotEmpty ( ) ) { appendLine ( \"\" ) unexpectedPropertyValues . forEach { issue -> appendLine ( \"\" ) } } if ( missingProperties . isNotEmpty ( ) ) { if ( unexpectedPropertyValues . isNotEmpty ( ) ) appendLine ( ) appendLine ( \"\" ) missingProperties . forEach { issue -> appendLine ( \"\" ) } } } ) }","docstring":"/**\n * Mechanism to warn developers when a given Gradle property does not match the developer's expectation.\n *\n * There may be some Gradle properties, that are defined in the project and will change over time (e.g. defaultSnapshotVersion).\n * Some developers (and QA) will need to be very clear about the value of this property.\n *\n * In order to get notified about the value of the property changing, it is possible to define the same property in\n * ~/.gradle/gradle.properties with a given `.kotlin_build.expected_value` suffix to ensure the value.\n *\n * e.g. if a developer set's\n *\n * `defaultSnapshotVersion.kotlin_build.expected_value=1.6.255-SNAPSHOT` and the value gets bumped to `2.0.255-SNAPSHOT` after pulling from master,\n * the developer will notice this during project configuration phase.\n */"} {"signature":"public fun extensionReceiverType ( type : ConeKotlinType )","body":"{ extensionReceiverType { type } }","docstring":"/**\n * Sets [type] as extension receiver type of constructed property\n */"} {"signature":"public fun extensionReceiverType ( typeProvider : ( List < FirTypeParameter > ) -> ConeKotlinType )","body":"{ extensionReceiverTypeProvider = typeProvider }","docstring":"/**\n * Sets type, provided by [typeProvider], as extension receiver type of constructed property\n *\n * Use this overload when extension receiver type uses type parameters of constructed property\n */"} {"signature":"public fun setter ( visibility : Visibility )","body":"{ setterVisibility = visibility }","docstring":"/**\n * Declares [visibility] of property setter if property marked as var\n * If this function is not called then setter will have same visibility\n * as property itself\n */"} {"signature":"public fun FirExtension . createMemberProperty ( owner : FirClassSymbol < * > , key : GeneratedDeclarationKey , name : Name , returnType : ConeKotlinType , isVal : Boolean = true , hasBackingField : Boolean = true , config : PropertyBuildingContext . ( ) -> Unit = { } ) : FirProperty","body":"{ return createMemberProperty ( owner , key , name , { returnType } , isVal , hasBackingField , config ) }","docstring":"/**\n * Creates a member property for [owner] class with [returnType] return type\n */"} {"signature":"public fun FirExtension . createMemberProperty ( owner : FirClassSymbol < * > , key : GeneratedDeclarationKey , name : Name , returnTypeProvider : ( List < FirTypeParameterRef > ) -> ConeKotlinType , isVal : Boolean = true , hasBackingField : Boolean = true , config : PropertyBuildingContext . ( ) -> Unit = { } ) : FirProperty","body":"{ val callableId = CallableId ( owner . classId , name ) return PropertyBuildingContext ( session , key , owner , callableId , returnTypeProvider , isVal , hasBackingField ) . apply ( config ) . apply { status { isExpect = owner . isExpect } } . build ( ) }","docstring":"/**\n * Creates a member property for [owner] class with return type provided by [returnTypeProvider]\n * Use this overload when those types use type parameters of constructed property\n */"} {"signature":"@ ExperimentalTopLevelDeclarationsGenerationApi public fun FirExtension . createTopLevelProperty ( key : GeneratedDeclarationKey , callableId : CallableId , returnType : ConeKotlinType , isVal : Boolean = true , hasBackingField : Boolean = true , config : PropertyBuildingContext . ( ) -> Unit = { } ) : FirProperty","body":"{ return createTopLevelProperty ( key , callableId , { returnType } , isVal , hasBackingField , config ) }","docstring":"/**\n * Creates a top-level property class with [returnType] return type\n *\n * If you create top-level extension property don't forget to set [hasBackingField] to false,\n * since such properties never have backing fields\n */"} {"signature":"@ ExperimentalTopLevelDeclarationsGenerationApi public fun FirExtension . createTopLevelProperty ( key : GeneratedDeclarationKey , callableId : CallableId , returnTypeProvider : ( List < FirTypeParameterRef > ) -> ConeKotlinType , isVal : Boolean = true , hasBackingField : Boolean = true , config : PropertyBuildingContext . ( ) -> Unit = { } ) : FirProperty","body":"{ require ( callableId . classId == null ) return PropertyBuildingContext ( session , key , owner = null , callableId , returnTypeProvider , isVal , hasBackingField ) . apply ( config ) . build ( ) }","docstring":"/**\n * Creates a top-level property with return type provided by [returnTypeProvider]\n *\n * If you create top-level extension property don't forget to set [hasBackingField] to false,\n * since such properties never have backing fields\n *\n * Use this overload when those types use type parameters of constructed property\n */"} {"signature":"private fun createWebpackConfig ( forNpmDependencies : Boolean = false )","body":"= KotlinWebpackConfig ( npmProjectDir = npmProjectDir , mode = mode , entry = if ( forNpmDependencies ) null else entry . get ( ) . asFile , output = output , outputPath = if ( forNpmDependencies ) null else outputDirectory . getOrNull ( ) ? . asFile , outputFileName = mainOutputFileName . get ( ) , configDirectory = configDirectory , rules = rules , devServer = devServerProperty . orNull , devtool = devtool , sourceMaps = sourceMaps , resolveFromModulesFirst = resolveFromModulesFirst , )","docstring":"/**\n * [forNpmDependencies] is used to avoid querying [outputDirectory] before task execution.\n * Otherwise, Gradle will fail the build.\n */"} {"signature":"@ kotlin . internal . InlineOnly public actual inline fun < T > Array < out T > . elementAt ( index : Int ) : T","body":"{ return get ( index ) }","docstring":"/**\n * Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.\n * \n * @sample samples.collections.Collections.Elements.elementAt\n */"} {"signature":"@ kotlin . internal . InlineOnly public actual inline fun ByteArray . elementAt ( index : Int ) : Byte","body":"{ return get ( index ) }","docstring":"/**\n * Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.\n * \n * @sample samples.collections.Collections.Elements.elementAt\n */"} {"signature":"@ kotlin . internal . InlineOnly public actual inline fun ShortArray . elementAt ( index : Int ) : Short","body":"{ return get ( index ) }","docstring":"/**\n * Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.\n * \n * @sample samples.collections.Collections.Elements.elementAt\n */"} {"signature":"@ kotlin . internal . InlineOnly public actual inline fun IntArray . elementAt ( index : Int ) : Int","body":"{ return get ( index ) }","docstring":"/**\n * Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.\n * \n * @sample samples.collections.Collections.Elements.elementAt\n */"} {"signature":"@ kotlin . internal . InlineOnly public actual inline fun LongArray . elementAt ( index : Int ) : Long","body":"{ return get ( index ) }","docstring":"/**\n * Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.\n * \n * @sample samples.collections.Collections.Elements.elementAt\n */"} {"signature":"@ kotlin . internal . InlineOnly public actual inline fun FloatArray . elementAt ( index : Int ) : Float","body":"{ return get ( index ) }","docstring":"/**\n * Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.\n * \n * @sample samples.collections.Collections.Elements.elementAt\n */"} {"signature":"@ kotlin . internal . InlineOnly public actual inline fun DoubleArray . elementAt ( index : Int ) : Double","body":"{ return get ( index ) }","docstring":"/**\n * Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.\n * \n * @sample samples.collections.Collections.Elements.elementAt\n */"} {"signature":"@ kotlin . internal . InlineOnly public actual inline fun BooleanArray . elementAt ( index : Int ) : Boolean","body":"{ return get ( index ) }","docstring":"/**\n * Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.\n * \n * @sample samples.collections.Collections.Elements.elementAt\n */"} {"signature":"@ kotlin . internal . InlineOnly public actual inline fun CharArray . elementAt ( index : Int ) : Char","body":"{ return get ( index ) }","docstring":"/**\n * Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.\n * \n * @sample samples.collections.Collections.Elements.elementAt\n */"} {"signature":"public actual fun < T > Array < out T > . asList ( ) : List < T >","body":"{ return object : AbstractList < T > ( ) , RandomAccess { override val size : Int get ( ) = this@asList . size override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) override fun contains ( element : T ) : Boolean = this@asList . contains ( element ) override fun get ( index : Int ) : T = this@asList [ index ] override fun indexOf ( element : T ) : Int = this@asList . indexOf ( element ) override fun lastIndexOf ( element : T ) : Int = this@asList . lastIndexOf ( element ) } }","docstring":"/**\n * Returns a [List] that wraps the original array.\n */"} {"signature":"public actual fun ByteArray . asList ( ) : List < Byte >","body":"{ return object : AbstractList < Byte > ( ) , RandomAccess { override val size : Int get ( ) = this@asList . size override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) override fun contains ( element : Byte ) : Boolean = this@asList . contains ( element ) override fun get ( index : Int ) : Byte = this@asList [ index ] override fun indexOf ( element : Byte ) : Int = this@asList . indexOf ( element ) override fun lastIndexOf ( element : Byte ) : Int = this@asList . lastIndexOf ( element ) } }","docstring":"/**\n * Returns a [List] that wraps the original array.\n */"} {"signature":"public actual fun ShortArray . asList ( ) : List < Short >","body":"{ return object : AbstractList < Short > ( ) , RandomAccess { override val size : Int get ( ) = this@asList . size override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) override fun contains ( element : Short ) : Boolean = this@asList . contains ( element ) override fun get ( index : Int ) : Short = this@asList [ index ] override fun indexOf ( element : Short ) : Int = this@asList . indexOf ( element ) override fun lastIndexOf ( element : Short ) : Int = this@asList . lastIndexOf ( element ) } }","docstring":"/**\n * Returns a [List] that wraps the original array.\n */"} {"signature":"public actual fun IntArray . asList ( ) : List < Int >","body":"{ return object : AbstractList < Int > ( ) , RandomAccess { override val size : Int get ( ) = this@asList . size override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) override fun contains ( element : Int ) : Boolean = this@asList . contains ( element ) override fun get ( index : Int ) : Int = this@asList [ index ] override fun indexOf ( element : Int ) : Int = this@asList . indexOf ( element ) override fun lastIndexOf ( element : Int ) : Int = this@asList . lastIndexOf ( element ) } }","docstring":"/**\n * Returns a [List] that wraps the original array.\n */"} {"signature":"public actual fun LongArray . asList ( ) : List < Long >","body":"{ return object : AbstractList < Long > ( ) , RandomAccess { override val size : Int get ( ) = this@asList . size override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) override fun contains ( element : Long ) : Boolean = this@asList . contains ( element ) override fun get ( index : Int ) : Long = this@asList [ index ] override fun indexOf ( element : Long ) : Int = this@asList . indexOf ( element ) override fun lastIndexOf ( element : Long ) : Int = this@asList . lastIndexOf ( element ) } }","docstring":"/**\n * Returns a [List] that wraps the original array.\n */"} {"signature":"public actual fun FloatArray . asList ( ) : List < Float >","body":"{ return object : AbstractList < Float > ( ) , RandomAccess { override val size : Int get ( ) = this@asList . size override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) override fun contains ( element : Float ) : Boolean = this@asList . any { it . toBits ( ) == element . toBits ( ) } override fun get ( index : Int ) : Float = this@asList [ index ] override fun indexOf ( element : Float ) : Int = this@asList . indexOfFirst { it . toBits ( ) == element . toBits ( ) } override fun lastIndexOf ( element : Float ) : Int = this@asList . indexOfLast { it . toBits ( ) == element . toBits ( ) } } }","docstring":"/**\n * Returns a [List] that wraps the original array.\n */"} {"signature":"public actual fun DoubleArray . asList ( ) : List < Double >","body":"{ return object : AbstractList < Double > ( ) , RandomAccess { override val size : Int get ( ) = this@asList . size override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) override fun contains ( element : Double ) : Boolean = this@asList . any { it . toBits ( ) == element . toBits ( ) } override fun get ( index : Int ) : Double = this@asList [ index ] override fun indexOf ( element : Double ) : Int = this@asList . indexOfFirst { it . toBits ( ) == element . toBits ( ) } override fun lastIndexOf ( element : Double ) : Int = this@asList . indexOfLast { it . toBits ( ) == element . toBits ( ) } } }","docstring":"/**\n * Returns a [List] that wraps the original array.\n */"} {"signature":"public actual fun BooleanArray . asList ( ) : List < Boolean >","body":"{ return object : AbstractList < Boolean > ( ) , RandomAccess { override val size : Int get ( ) = this@asList . size override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) override fun contains ( element : Boolean ) : Boolean = this@asList . contains ( element ) override fun get ( index : Int ) : Boolean = this@asList [ index ] override fun indexOf ( element : Boolean ) : Int = this@asList . indexOf ( element ) override fun lastIndexOf ( element : Boolean ) : Int = this@asList . lastIndexOf ( element ) } }","docstring":"/**\n * Returns a [List] that wraps the original array.\n */"} {"signature":"public actual fun CharArray . asList ( ) : List < Char >","body":"{ return object : AbstractList < Char > ( ) , RandomAccess { override val size : Int get ( ) = this@asList . size override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) override fun contains ( element : Char ) : Boolean = this@asList . contains ( element ) override fun get ( index : Int ) : Char = this@asList [ index ] override fun indexOf ( element : Char ) : Int = this@asList . indexOf ( element ) override fun lastIndexOf ( element : Char ) : Int = this@asList . lastIndexOf ( element ) } }","docstring":"/**\n * Returns a [List] that wraps the original array.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ kotlin . internal . LowPriorityInOverloadResolution public actual infix fun < T > Array < out T > . contentDeepEquals ( other : Array < out T > ) : Boolean","body":"{ return this . contentDeepEquals ( other ) }","docstring":"/**\n * Checks if the two specified arrays are *deeply* equal to one another.\n * \n * Two arrays are considered deeply equal if they have the same size, and elements at corresponding indices are deeply equal.\n * That is, if two corresponding elements are nested arrays, they are also compared deeply.\n * Elements of other types are compared for equality using the [equals][Any.equals] function.\n * For floating point numbers, this means `NaN` is equal to itself and `-0.0` is not equal to `0.0`.\n * \n * If any of the arrays contain themselves at any nesting level, the behavior is undefined.\n * \n * @param other the array to compare deeply with this array.\n * @return `true` if the two arrays are deeply equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.contentDeepEquals\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual infix fun < T > Array < out T > ? . contentDeepEquals ( other : Array < out T > ? ) : Boolean","body":"{ return contentDeepEqualsImpl ( other ) }","docstring":"/**\n * Checks if the two specified arrays are *deeply* equal to one another.\n * \n * Two arrays are considered deeply equal if they have the same size, and elements at corresponding indices are deeply equal.\n * That is, if two corresponding elements are nested arrays, they are also compared deeply.\n * Elements of other types are compared for equality using the [equals][Any.equals] function.\n * For floating point numbers, this means `NaN` is equal to itself and `-0.0` is not equal to `0.0`.\n * \n * The arrays are also considered deeply equal if both are `null`.\n * \n * If any of the arrays contain themselves at any nesting level, the behavior is undefined.\n * \n * @param other the array to compare deeply with this array.\n * @return `true` if the two arrays are deeply equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.contentDeepEquals\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ kotlin . internal . LowPriorityInOverloadResolution public actual fun < T > Array < out T > . contentDeepHashCode ( ) : Int","body":"{ return this . contentDeepHashCode ( ) }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n * Nested arrays are treated as lists too.\n * \n * If any of arrays contains itself on any nesting level the behavior is undefined.\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual fun < T > Array < out T > ? . contentDeepHashCode ( ) : Int","body":"{ return contentDeepHashCodeImpl ( ) }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n * Nested arrays are treated as lists too.\n * \n * If any of arrays contains itself on any nesting level the behavior is undefined.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ kotlin . internal . LowPriorityInOverloadResolution public actual fun < T > Array < out T > . contentDeepToString ( ) : String","body":"{ return this . contentDeepToString ( ) }","docstring":"/**\n * Returns a string representation of the contents of this array as if it is a [List].\n * Nested arrays are treated as lists too.\n * \n * If any of arrays contains itself on any nesting level that reference\n * is rendered as `\"[...]\"` to prevent recursion.\n * \n * @sample samples.collections.Arrays.ContentOperations.contentDeepToString\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual fun < T > Array < out T > ? . contentDeepToString ( ) : String","body":"{ return contentDeepToStringImpl ( ) }","docstring":"/**\n * Returns a string representation of the contents of this array as if it is a [List].\n * Nested arrays are treated as lists too.\n * \n * If any of arrays contains itself on any nesting level that reference\n * is rendered as `\"[...]\"` to prevent recursion.\n * \n * @sample samples.collections.Arrays.ContentOperations.contentDeepToString\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) public infix fun < T > Array < out T > . contentEquals ( other : Array < out T > ) : Boolean","body":"{ return this . contentEquals ( other ) }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * Elements are compared for equality using the [equals][Any.equals] function.\n * For floating point numbers, this means `NaN` is equal to itself and `-0.0` is not equal to `0.0`.\n * \n * If the arrays contain nested arrays, use [contentDeepEquals] to recursively compare their elements.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.arrayContentEquals\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) public infix fun ByteArray . contentEquals ( other : ByteArray ) : Boolean","body":"{ return this . contentEquals ( other ) }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.intArrayContentEquals\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) public infix fun ShortArray . contentEquals ( other : ShortArray ) : Boolean","body":"{ return this . contentEquals ( other ) }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.intArrayContentEquals\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) public infix fun IntArray . contentEquals ( other : IntArray ) : Boolean","body":"{ return this . contentEquals ( other ) }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.intArrayContentEquals\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) public infix fun LongArray . contentEquals ( other : LongArray ) : Boolean","body":"{ return this . contentEquals ( other ) }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.intArrayContentEquals\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) public infix fun FloatArray . contentEquals ( other : FloatArray ) : Boolean","body":"{ return this . contentEquals ( other ) }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * Elements are compared for equality using the [equals][Any.equals] function.\n * This means `NaN` is equal to itself and `-0.0` is not equal to `0.0`.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.doubleArrayContentEquals\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) public infix fun DoubleArray . contentEquals ( other : DoubleArray ) : Boolean","body":"{ return this . contentEquals ( other ) }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * Elements are compared for equality using the [equals][Any.equals] function.\n * This means `NaN` is equal to itself and `-0.0` is not equal to `0.0`.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.doubleArrayContentEquals\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) public infix fun BooleanArray . contentEquals ( other : BooleanArray ) : Boolean","body":"{ return this . contentEquals ( other ) }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.booleanArrayContentEquals\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) public infix fun CharArray . contentEquals ( other : CharArray ) : Boolean","body":"{ return this . contentEquals ( other ) }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.charArrayContentEquals\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual infix fun < T > Array < out T > ? . contentEquals ( other : Array < out T > ? ) : Boolean","body":"{ if ( this === other ) return true if ( this === null || other === null ) return false if ( size != other . size ) return false for ( i in indices ) { if ( this [ i ] != other [ i ] ) return false } return true }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * Elements are compared for equality using the [equals][Any.equals] function.\n * For floating point numbers, this means `NaN` is equal to itself and `-0.0` is not equal to `0.0`.\n * \n * The arrays are also considered structurally equal if both are `null`.\n * \n * If the arrays contain nested arrays, use [contentDeepEquals] to recursively compare their elements.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.arrayContentEquals\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual infix fun ByteArray ? . contentEquals ( other : ByteArray ? ) : Boolean","body":"{ if ( this === other ) return true if ( this === null || other === null ) return false if ( size != other . size ) return false for ( i in indices ) { if ( this [ i ] != other [ i ] ) return false } return true }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * \n * The arrays are also considered structurally equal if both are `null`.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.intArrayContentEquals\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual infix fun ShortArray ? . contentEquals ( other : ShortArray ? ) : Boolean","body":"{ if ( this === other ) return true if ( this === null || other === null ) return false if ( size != other . size ) return false for ( i in indices ) { if ( this [ i ] != other [ i ] ) return false } return true }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * \n * The arrays are also considered structurally equal if both are `null`.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.intArrayContentEquals\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual infix fun IntArray ? . contentEquals ( other : IntArray ? ) : Boolean","body":"{ if ( this === other ) return true if ( this === null || other === null ) return false if ( size != other . size ) return false for ( i in indices ) { if ( this [ i ] != other [ i ] ) return false } return true }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * \n * The arrays are also considered structurally equal if both are `null`.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.intArrayContentEquals\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual infix fun LongArray ? . contentEquals ( other : LongArray ? ) : Boolean","body":"{ if ( this === other ) return true if ( this === null || other === null ) return false if ( size != other . size ) return false for ( i in indices ) { if ( this [ i ] != other [ i ] ) return false } return true }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * \n * The arrays are also considered structurally equal if both are `null`.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.intArrayContentEquals\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual infix fun FloatArray ? . contentEquals ( other : FloatArray ? ) : Boolean","body":"{ if ( this === other ) return true if ( this === null || other === null ) return false if ( size != other . size ) return false for ( i in indices ) { if ( ! this [ i ] . equals ( other [ i ] ) ) return false } return true }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * Elements are compared for equality using the [equals][Any.equals] function.\n * This means `NaN` is equal to itself and `-0.0` is not equal to `0.0`.\n * \n * The arrays are also considered structurally equal if both are `null`.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.doubleArrayContentEquals\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual infix fun DoubleArray ? . contentEquals ( other : DoubleArray ? ) : Boolean","body":"{ if ( this === other ) return true if ( this === null || other === null ) return false if ( size != other . size ) return false for ( i in indices ) { if ( ! this [ i ] . equals ( other [ i ] ) ) return false } return true }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * Elements are compared for equality using the [equals][Any.equals] function.\n * This means `NaN` is equal to itself and `-0.0` is not equal to `0.0`.\n * \n * The arrays are also considered structurally equal if both are `null`.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.doubleArrayContentEquals\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual infix fun BooleanArray ? . contentEquals ( other : BooleanArray ? ) : Boolean","body":"{ if ( this === other ) return true if ( this === null || other === null ) return false if ( size != other . size ) return false for ( i in indices ) { if ( this [ i ] != other [ i ] ) return false } return true }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * \n * The arrays are also considered structurally equal if both are `null`.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.booleanArrayContentEquals\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual infix fun CharArray ? . contentEquals ( other : CharArray ? ) : Boolean","body":"{ if ( this === other ) return true if ( this === null || other === null ) return false if ( size != other . size ) return false for ( i in indices ) { if ( this [ i ] != other [ i ] ) return false } return true }","docstring":"/**\n * Checks if the two specified arrays are *structurally* equal to one another.\n * \n * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.\n * \n * The arrays are also considered structurally equal if both are `null`.\n * \n * @param other the array to compare with this array.\n * @return `true` if the two arrays are structurally equal, `false` otherwise.\n * \n * @sample samples.collections.Arrays.ContentOperations.charArrayContentEquals\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) public fun < T > Array < out T > . contentHashCode ( ) : Int","body":"{ return this . contentHashCode ( ) }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) public fun ByteArray . contentHashCode ( ) : Int","body":"{ return this . contentHashCode ( ) }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) public fun ShortArray . contentHashCode ( ) : Int","body":"{ return this . contentHashCode ( ) }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) public fun IntArray . contentHashCode ( ) : Int","body":"{ return this . contentHashCode ( ) }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) public fun LongArray . contentHashCode ( ) : Int","body":"{ return this . contentHashCode ( ) }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) public fun FloatArray . contentHashCode ( ) : Int","body":"{ return this . contentHashCode ( ) }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) public fun DoubleArray . contentHashCode ( ) : Int","body":"{ return this . contentHashCode ( ) }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) public fun BooleanArray . contentHashCode ( ) : Int","body":"{ return this . contentHashCode ( ) }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) public fun CharArray . contentHashCode ( ) : Int","body":"{ return this . contentHashCode ( ) }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual fun < T > Array < out T > ? . contentHashCode ( ) : Int","body":"{ if ( this === null ) return var result = for ( element in this ) result = * result + element . hashCode ( ) return result }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual fun ByteArray ? . contentHashCode ( ) : Int","body":"{ if ( this === null ) return var result = for ( element in this ) result = * result + element . hashCode ( ) return result }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual fun ShortArray ? . contentHashCode ( ) : Int","body":"{ if ( this === null ) return var result = for ( element in this ) result = * result + element . hashCode ( ) return result }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual fun IntArray ? . contentHashCode ( ) : Int","body":"{ if ( this === null ) return var result = for ( element in this ) result = * result + element . hashCode ( ) return result }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual fun LongArray ? . contentHashCode ( ) : Int","body":"{ if ( this === null ) return var result = for ( element in this ) result = * result + element . hashCode ( ) return result }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual fun FloatArray ? . contentHashCode ( ) : Int","body":"{ if ( this === null ) return var result = for ( element in this ) result = * result + element . hashCode ( ) return result }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual fun DoubleArray ? . contentHashCode ( ) : Int","body":"{ if ( this === null ) return var result = for ( element in this ) result = * result + element . hashCode ( ) return result }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual fun BooleanArray ? . contentHashCode ( ) : Int","body":"{ if ( this === null ) return var result = for ( element in this ) result = * result + element . hashCode ( ) return result }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual fun CharArray ? . contentHashCode ( ) : Int","body":"{ if ( this === null ) return var result = for ( element in this ) result = * result + element . hashCode ( ) return result }","docstring":"/**\n * Returns a hash code based on the contents of this array as if it is [List].\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) public fun < T > Array < out T > . contentToString ( ) : String","body":"{ return this . contentToString ( ) }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) public fun ByteArray . contentToString ( ) : String","body":"{ return this . contentToString ( ) }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) public fun ShortArray . contentToString ( ) : String","body":"{ return this . contentToString ( ) }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) public fun IntArray . contentToString ( ) : String","body":"{ return this . contentToString ( ) }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) public fun LongArray . contentToString ( ) : String","body":"{ return this . contentToString ( ) }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) public fun FloatArray . contentToString ( ) : String","body":"{ return this . contentToString ( ) }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) public fun DoubleArray . contentToString ( ) : String","body":"{ return this . contentToString ( ) }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) public fun BooleanArray . contentToString ( ) : String","body":"{ return this . contentToString ( ) }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"} {"signature":"@ Deprecated ( \"\" ) @ SinceKotlin ( \"\" ) @ DeprecatedSinceKotlin ( hiddenSince = \"\" ) public fun CharArray . contentToString ( ) : String","body":"{ return this . contentToString ( ) }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual fun < T > Array < out T > ? . contentToString ( ) : String","body":"{ return this ? . joinToString ( \"\" , \"\" , \"\" ) ? : \"\" }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual fun ByteArray ? . contentToString ( ) : String","body":"{ return this ? . joinToString ( \"\" , \"\" , \"\" ) ? : \"\" }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual fun ShortArray ? . contentToString ( ) : String","body":"{ return this ? . joinToString ( \"\" , \"\" , \"\" ) ? : \"\" }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual fun IntArray ? . contentToString ( ) : String","body":"{ return this ? . joinToString ( \"\" , \"\" , \"\" ) ? : \"\" }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual fun LongArray ? . contentToString ( ) : String","body":"{ return this ? . joinToString ( \"\" , \"\" , \"\" ) ? : \"\" }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual fun FloatArray ? . contentToString ( ) : String","body":"{ return this ? . joinToString ( \"\" , \"\" , \"\" ) ? : \"\" }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual fun DoubleArray ? . contentToString ( ) : String","body":"{ return this ? . joinToString ( \"\" , \"\" , \"\" ) ? : \"\" }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual fun BooleanArray ? . contentToString ( ) : String","body":"{ return this ? . joinToString ( \"\" , \"\" , \"\" ) ? : \"\" }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual fun CharArray ? . contentToString ( ) : String","body":"{ return this ? . joinToString ( \"\" , \"\" , \"\" ) ? : \"\" }","docstring":"/**\n * Returns a string representation of the contents of the specified array as if it is [List].\n * \n * @sample samples.collections.Arrays.ContentOperations.contentToString\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" ) public actual fun < T > Array < out T > . copyInto ( destination : Array < T > , destinationOffset : Int = , startIndex : Int = , endIndex : Int = size ) : Array < T >","body":"{ @ Suppress ( \"\" ) arrayCopy ( this as Array < Any ? > , startIndex , destination as Array < Any ? > , destinationOffset , endIndex - startIndex ) return destination }","docstring":"/**\n * Copies this array or its subrange into the [destination] array and returns that array.\n * \n * It's allowed to pass the same array in the [destination] and even specify the subrange so that it overlaps with the destination range.\n * \n * @param destination the array to copy to.\n * @param destinationOffset the position in the [destination] array to copy to, 0 by default.\n * @param startIndex the beginning (inclusive) of the subrange to copy, 0 by default.\n * @param endIndex the end (exclusive) of the subrange to copy, size of this array by default.\n * \n * @throws IndexOutOfBoundsException or [IllegalArgumentException] when [startIndex] or [endIndex] is out of range of this array indices or when `startIndex > endIndex`.\n * @throws IndexOutOfBoundsException when the subrange doesn't fit into the [destination] array starting at the specified [destinationOffset],\n * or when that index is out of the [destination] array indices range.\n * \n * @return the [destination] array.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" ) public actual fun ByteArray . copyInto ( destination : ByteArray , destinationOffset : Int = , startIndex : Int = , endIndex : Int = size ) : ByteArray","body":"{ arrayCopy ( this , startIndex , destination , destinationOffset , endIndex - startIndex ) return destination }","docstring":"/**\n * Copies this array or its subrange into the [destination] array and returns that array.\n * \n * It's allowed to pass the same array in the [destination] and even specify the subrange so that it overlaps with the destination range.\n * \n * @param destination the array to copy to.\n * @param destinationOffset the position in the [destination] array to copy to, 0 by default.\n * @param startIndex the beginning (inclusive) of the subrange to copy, 0 by default.\n * @param endIndex the end (exclusive) of the subrange to copy, size of this array by default.\n * \n * @throws IndexOutOfBoundsException or [IllegalArgumentException] when [startIndex] or [endIndex] is out of range of this array indices or when `startIndex > endIndex`.\n * @throws IndexOutOfBoundsException when the subrange doesn't fit into the [destination] array starting at the specified [destinationOffset],\n * or when that index is out of the [destination] array indices range.\n * \n * @return the [destination] array.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" ) public actual fun ShortArray . copyInto ( destination : ShortArray , destinationOffset : Int = , startIndex : Int = , endIndex : Int = size ) : ShortArray","body":"{ arrayCopy ( this , startIndex , destination , destinationOffset , endIndex - startIndex ) return destination }","docstring":"/**\n * Copies this array or its subrange into the [destination] array and returns that array.\n * \n * It's allowed to pass the same array in the [destination] and even specify the subrange so that it overlaps with the destination range.\n * \n * @param destination the array to copy to.\n * @param destinationOffset the position in the [destination] array to copy to, 0 by default.\n * @param startIndex the beginning (inclusive) of the subrange to copy, 0 by default.\n * @param endIndex the end (exclusive) of the subrange to copy, size of this array by default.\n * \n * @throws IndexOutOfBoundsException or [IllegalArgumentException] when [startIndex] or [endIndex] is out of range of this array indices or when `startIndex > endIndex`.\n * @throws IndexOutOfBoundsException when the subrange doesn't fit into the [destination] array starting at the specified [destinationOffset],\n * or when that index is out of the [destination] array indices range.\n * \n * @return the [destination] array.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" ) public actual fun IntArray . copyInto ( destination : IntArray , destinationOffset : Int = , startIndex : Int = , endIndex : Int = size ) : IntArray","body":"{ arrayCopy ( this , startIndex , destination , destinationOffset , endIndex - startIndex ) return destination }","docstring":"/**\n * Copies this array or its subrange into the [destination] array and returns that array.\n * \n * It's allowed to pass the same array in the [destination] and even specify the subrange so that it overlaps with the destination range.\n * \n * @param destination the array to copy to.\n * @param destinationOffset the position in the [destination] array to copy to, 0 by default.\n * @param startIndex the beginning (inclusive) of the subrange to copy, 0 by default.\n * @param endIndex the end (exclusive) of the subrange to copy, size of this array by default.\n * \n * @throws IndexOutOfBoundsException or [IllegalArgumentException] when [startIndex] or [endIndex] is out of range of this array indices or when `startIndex > endIndex`.\n * @throws IndexOutOfBoundsException when the subrange doesn't fit into the [destination] array starting at the specified [destinationOffset],\n * or when that index is out of the [destination] array indices range.\n * \n * @return the [destination] array.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" ) public actual fun LongArray . copyInto ( destination : LongArray , destinationOffset : Int = , startIndex : Int = , endIndex : Int = size ) : LongArray","body":"{ arrayCopy ( this , startIndex , destination , destinationOffset , endIndex - startIndex ) return destination }","docstring":"/**\n * Copies this array or its subrange into the [destination] array and returns that array.\n * \n * It's allowed to pass the same array in the [destination] and even specify the subrange so that it overlaps with the destination range.\n * \n * @param destination the array to copy to.\n * @param destinationOffset the position in the [destination] array to copy to, 0 by default.\n * @param startIndex the beginning (inclusive) of the subrange to copy, 0 by default.\n * @param endIndex the end (exclusive) of the subrange to copy, size of this array by default.\n * \n * @throws IndexOutOfBoundsException or [IllegalArgumentException] when [startIndex] or [endIndex] is out of range of this array indices or when `startIndex > endIndex`.\n * @throws IndexOutOfBoundsException when the subrange doesn't fit into the [destination] array starting at the specified [destinationOffset],\n * or when that index is out of the [destination] array indices range.\n * \n * @return the [destination] array.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" ) public actual fun FloatArray . copyInto ( destination : FloatArray , destinationOffset : Int = , startIndex : Int = , endIndex : Int = size ) : FloatArray","body":"{ arrayCopy ( this , startIndex , destination , destinationOffset , endIndex - startIndex ) return destination }","docstring":"/**\n * Copies this array or its subrange into the [destination] array and returns that array.\n * \n * It's allowed to pass the same array in the [destination] and even specify the subrange so that it overlaps with the destination range.\n * \n * @param destination the array to copy to.\n * @param destinationOffset the position in the [destination] array to copy to, 0 by default.\n * @param startIndex the beginning (inclusive) of the subrange to copy, 0 by default.\n * @param endIndex the end (exclusive) of the subrange to copy, size of this array by default.\n * \n * @throws IndexOutOfBoundsException or [IllegalArgumentException] when [startIndex] or [endIndex] is out of range of this array indices or when `startIndex > endIndex`.\n * @throws IndexOutOfBoundsException when the subrange doesn't fit into the [destination] array starting at the specified [destinationOffset],\n * or when that index is out of the [destination] array indices range.\n * \n * @return the [destination] array.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" ) public actual fun DoubleArray . copyInto ( destination : DoubleArray , destinationOffset : Int = , startIndex : Int = , endIndex : Int = size ) : DoubleArray","body":"{ arrayCopy ( this , startIndex , destination , destinationOffset , endIndex - startIndex ) return destination }","docstring":"/**\n * Copies this array or its subrange into the [destination] array and returns that array.\n * \n * It's allowed to pass the same array in the [destination] and even specify the subrange so that it overlaps with the destination range.\n * \n * @param destination the array to copy to.\n * @param destinationOffset the position in the [destination] array to copy to, 0 by default.\n * @param startIndex the beginning (inclusive) of the subrange to copy, 0 by default.\n * @param endIndex the end (exclusive) of the subrange to copy, size of this array by default.\n * \n * @throws IndexOutOfBoundsException or [IllegalArgumentException] when [startIndex] or [endIndex] is out of range of this array indices or when `startIndex > endIndex`.\n * @throws IndexOutOfBoundsException when the subrange doesn't fit into the [destination] array starting at the specified [destinationOffset],\n * or when that index is out of the [destination] array indices range.\n * \n * @return the [destination] array.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" ) public actual fun BooleanArray . copyInto ( destination : BooleanArray , destinationOffset : Int = , startIndex : Int = , endIndex : Int = size ) : BooleanArray","body":"{ arrayCopy ( this , startIndex , destination , destinationOffset , endIndex - startIndex ) return destination }","docstring":"/**\n * Copies this array or its subrange into the [destination] array and returns that array.\n * \n * It's allowed to pass the same array in the [destination] and even specify the subrange so that it overlaps with the destination range.\n * \n * @param destination the array to copy to.\n * @param destinationOffset the position in the [destination] array to copy to, 0 by default.\n * @param startIndex the beginning (inclusive) of the subrange to copy, 0 by default.\n * @param endIndex the end (exclusive) of the subrange to copy, size of this array by default.\n * \n * @throws IndexOutOfBoundsException or [IllegalArgumentException] when [startIndex] or [endIndex] is out of range of this array indices or when `startIndex > endIndex`.\n * @throws IndexOutOfBoundsException when the subrange doesn't fit into the [destination] array starting at the specified [destinationOffset],\n * or when that index is out of the [destination] array indices range.\n * \n * @return the [destination] array.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" ) public actual fun CharArray . copyInto ( destination : CharArray , destinationOffset : Int = , startIndex : Int = , endIndex : Int = size ) : CharArray","body":"{ arrayCopy ( this , startIndex , destination , destinationOffset , endIndex - startIndex ) return destination }","docstring":"/**\n * Copies this array or its subrange into the [destination] array and returns that array.\n * \n * It's allowed to pass the same array in the [destination] and even specify the subrange so that it overlaps with the destination range.\n * \n * @param destination the array to copy to.\n * @param destinationOffset the position in the [destination] array to copy to, 0 by default.\n * @param startIndex the beginning (inclusive) of the subrange to copy, 0 by default.\n * @param endIndex the end (exclusive) of the subrange to copy, size of this array by default.\n * \n * @throws IndexOutOfBoundsException or [IllegalArgumentException] when [startIndex] or [endIndex] is out of range of this array indices or when `startIndex > endIndex`.\n * @throws IndexOutOfBoundsException when the subrange doesn't fit into the [destination] array starting at the specified [destinationOffset],\n * or when that index is out of the [destination] array indices range.\n * \n * @return the [destination] array.\n */"} {"signature":"public actual fun < T > Array < T > . copyOf ( ) : Array < T >","body":"{ return this . copyOfUninitializedElements ( size ) }","docstring":"/**\n * Returns new array which is a copy of the original array.\n * \n * @sample samples.collections.Arrays.CopyOfOperations.copyOf\n */"} {"signature":"public actual fun ByteArray . copyOf ( ) : ByteArray","body":"{ return this . copyOfUninitializedElements ( size ) }","docstring":"/**\n * Returns new array which is a copy of the original array.\n * \n * @sample samples.collections.Arrays.CopyOfOperations.copyOf\n */"} {"signature":"public actual fun ShortArray . copyOf ( ) : ShortArray","body":"{ return this . copyOfUninitializedElements ( size ) }","docstring":"/**\n * Returns new array which is a copy of the original array.\n * \n * @sample samples.collections.Arrays.CopyOfOperations.copyOf\n */"} {"signature":"public actual fun IntArray . copyOf ( ) : IntArray","body":"{ return this . copyOfUninitializedElements ( size ) }","docstring":"/**\n * Returns new array which is a copy of the original array.\n * \n * @sample samples.collections.Arrays.CopyOfOperations.copyOf\n */"} {"signature":"public actual fun LongArray . copyOf ( ) : LongArray","body":"{ return this . copyOfUninitializedElements ( size ) }","docstring":"/**\n * Returns new array which is a copy of the original array.\n * \n * @sample samples.collections.Arrays.CopyOfOperations.copyOf\n */"} {"signature":"public actual fun FloatArray . copyOf ( ) : FloatArray","body":"{ return this . copyOfUninitializedElements ( size ) }","docstring":"/**\n * Returns new array which is a copy of the original array.\n * \n * @sample samples.collections.Arrays.CopyOfOperations.copyOf\n */"} {"signature":"public actual fun DoubleArray . copyOf ( ) : DoubleArray","body":"{ return this . copyOfUninitializedElements ( size ) }","docstring":"/**\n * Returns new array which is a copy of the original array.\n * \n * @sample samples.collections.Arrays.CopyOfOperations.copyOf\n */"} {"signature":"public actual fun BooleanArray . copyOf ( ) : BooleanArray","body":"{ return this . copyOfUninitializedElements ( size ) }","docstring":"/**\n * Returns new array which is a copy of the original array.\n * \n * @sample samples.collections.Arrays.CopyOfOperations.copyOf\n */"} {"signature":"public actual fun CharArray . copyOf ( ) : CharArray","body":"{ return this . copyOfUninitializedElements ( size ) }","docstring":"/**\n * Returns new array which is a copy of the original array.\n * \n * @sample samples.collections.Arrays.CopyOfOperations.copyOf\n */"} {"signature":"public actual fun ByteArray . copyOf ( newSize : Int ) : ByteArray","body":"{ return this . copyOfUninitializedElements ( newSize ) }","docstring":"/**\n * Returns new array which is a copy of the original array, resized to the given [newSize].\n * The copy is either truncated or padded at the end with zero values if necessary.\n * \n * - If [newSize] is less than the size of the original array, the copy array is truncated to the [newSize].\n * - If [newSize] is greater than the size of the original array, the extra elements in the copy array are filled with zero values.\n * \n * @sample samples.collections.Arrays.CopyOfOperations.resizedPrimitiveCopyOf\n */"} {"signature":"public actual fun ShortArray . copyOf ( newSize : Int ) : ShortArray","body":"{ return this . copyOfUninitializedElements ( newSize ) }","docstring":"/**\n * Returns new array which is a copy of the original array, resized to the given [newSize].\n * The copy is either truncated or padded at the end with zero values if necessary.\n * \n * - If [newSize] is less than the size of the original array, the copy array is truncated to the [newSize].\n * - If [newSize] is greater than the size of the original array, the extra elements in the copy array are filled with zero values.\n * \n * @sample samples.collections.Arrays.CopyOfOperations.resizedPrimitiveCopyOf\n */"} {"signature":"public actual fun IntArray . copyOf ( newSize : Int ) : IntArray","body":"{ return this . copyOfUninitializedElements ( newSize ) }","docstring":"/**\n * Returns new array which is a copy of the original array, resized to the given [newSize].\n * The copy is either truncated or padded at the end with zero values if necessary.\n * \n * - If [newSize] is less than the size of the original array, the copy array is truncated to the [newSize].\n * - If [newSize] is greater than the size of the original array, the extra elements in the copy array are filled with zero values.\n * \n * @sample samples.collections.Arrays.CopyOfOperations.resizedPrimitiveCopyOf\n */"} {"signature":"public actual fun LongArray . copyOf ( newSize : Int ) : LongArray","body":"{ return this . copyOfUninitializedElements ( newSize ) }","docstring":"/**\n * Returns new array which is a copy of the original array, resized to the given [newSize].\n * The copy is either truncated or padded at the end with zero values if necessary.\n * \n * - If [newSize] is less than the size of the original array, the copy array is truncated to the [newSize].\n * - If [newSize] is greater than the size of the original array, the extra elements in the copy array are filled with zero values.\n * \n * @sample samples.collections.Arrays.CopyOfOperations.resizedPrimitiveCopyOf\n */"} {"signature":"public actual fun FloatArray . copyOf ( newSize : Int ) : FloatArray","body":"{ return this . copyOfUninitializedElements ( newSize ) }","docstring":"/**\n * Returns new array which is a copy of the original array, resized to the given [newSize].\n * The copy is either truncated or padded at the end with zero values if necessary.\n * \n * - If [newSize] is less than the size of the original array, the copy array is truncated to the [newSize].\n * - If [newSize] is greater than the size of the original array, the extra elements in the copy array are filled with zero values.\n * \n * @sample samples.collections.Arrays.CopyOfOperations.resizedPrimitiveCopyOf\n */"} {"signature":"public actual fun DoubleArray . copyOf ( newSize : Int ) : DoubleArray","body":"{ return this . copyOfUninitializedElements ( newSize ) }","docstring":"/**\n * Returns new array which is a copy of the original array, resized to the given [newSize].\n * The copy is either truncated or padded at the end with zero values if necessary.\n * \n * - If [newSize] is less than the size of the original array, the copy array is truncated to the [newSize].\n * - If [newSize] is greater than the size of the original array, the extra elements in the copy array are filled with zero values.\n * \n * @sample samples.collections.Arrays.CopyOfOperations.resizedPrimitiveCopyOf\n */"} {"signature":"public actual fun BooleanArray . copyOf ( newSize : Int ) : BooleanArray","body":"{ return this . copyOfUninitializedElements ( newSize ) }","docstring":"/**\n * Returns new array which is a copy of the original array, resized to the given [newSize].\n * The copy is either truncated or padded at the end with `false` values if necessary.\n * \n * - If [newSize] is less than the size of the original array, the copy array is truncated to the [newSize].\n * - If [newSize] is greater than the size of the original array, the extra elements in the copy array are filled with `false` values.\n * \n * @sample samples.collections.Arrays.CopyOfOperations.resizedPrimitiveCopyOf\n */"} {"signature":"public actual fun CharArray . copyOf ( newSize : Int ) : CharArray","body":"{ return this . copyOfUninitializedElements ( newSize ) }","docstring":"/**\n * Returns new array which is a copy of the original array, resized to the given [newSize].\n * The copy is either truncated or padded at the end with null char (`\\u0000`) values if necessary.\n * \n * - If [newSize] is less than the size of the original array, the copy array is truncated to the [newSize].\n * - If [newSize] is greater than the size of the original array, the extra elements in the copy array are filled with null char (`\\u0000`) values.\n * \n * @sample samples.collections.Arrays.CopyOfOperations.resizedPrimitiveCopyOf\n */"} {"signature":"public actual fun < T > Array < T > . copyOf ( newSize : Int ) : Array < T ? >","body":"{ return this . copyOfNulls ( newSize ) }","docstring":"/**\n * Returns new array which is a copy of the original array, resized to the given [newSize].\n * The copy is either truncated or padded at the end with `null` values if necessary.\n * \n * - If [newSize] is less than the size of the original array, the copy array is truncated to the [newSize].\n * - If [newSize] is greater than the size of the original array, the extra elements in the copy array are filled with `null` values.\n * \n * @sample samples.collections.Arrays.CopyOfOperations.resizingCopyOf\n */"} {"signature":"public actual fun < T > Array < T > . copyOfRange ( fromIndex : Int , toIndex : Int ) : Array < T >","body":"{ checkCopyOfRangeArguments ( fromIndex , toIndex , size ) return copyOfUninitializedElements ( fromIndex , toIndex ) }","docstring":"/**\n * Returns a new array which is a copy of the specified range of the original array.\n * \n * @param fromIndex the start of the range (inclusive) to copy.\n * @param toIndex the end of the range (exclusive) to copy.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"} {"signature":"public actual fun ByteArray . copyOfRange ( fromIndex : Int , toIndex : Int ) : ByteArray","body":"{ checkCopyOfRangeArguments ( fromIndex , toIndex , size ) return copyOfUninitializedElements ( fromIndex , toIndex ) }","docstring":"/**\n * Returns a new array which is a copy of the specified range of the original array.\n * \n * @param fromIndex the start of the range (inclusive) to copy.\n * @param toIndex the end of the range (exclusive) to copy.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"} {"signature":"public actual fun ShortArray . copyOfRange ( fromIndex : Int , toIndex : Int ) : ShortArray","body":"{ checkCopyOfRangeArguments ( fromIndex , toIndex , size ) return copyOfUninitializedElements ( fromIndex , toIndex ) }","docstring":"/**\n * Returns a new array which is a copy of the specified range of the original array.\n * \n * @param fromIndex the start of the range (inclusive) to copy.\n * @param toIndex the end of the range (exclusive) to copy.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"} {"signature":"public actual fun IntArray . copyOfRange ( fromIndex : Int , toIndex : Int ) : IntArray","body":"{ checkCopyOfRangeArguments ( fromIndex , toIndex , size ) return copyOfUninitializedElements ( fromIndex , toIndex ) }","docstring":"/**\n * Returns a new array which is a copy of the specified range of the original array.\n * \n * @param fromIndex the start of the range (inclusive) to copy.\n * @param toIndex the end of the range (exclusive) to copy.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"} {"signature":"public actual fun LongArray . copyOfRange ( fromIndex : Int , toIndex : Int ) : LongArray","body":"{ checkCopyOfRangeArguments ( fromIndex , toIndex , size ) return copyOfUninitializedElements ( fromIndex , toIndex ) }","docstring":"/**\n * Returns a new array which is a copy of the specified range of the original array.\n * \n * @param fromIndex the start of the range (inclusive) to copy.\n * @param toIndex the end of the range (exclusive) to copy.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"} {"signature":"public actual fun FloatArray . copyOfRange ( fromIndex : Int , toIndex : Int ) : FloatArray","body":"{ checkCopyOfRangeArguments ( fromIndex , toIndex , size ) return copyOfUninitializedElements ( fromIndex , toIndex ) }","docstring":"/**\n * Returns a new array which is a copy of the specified range of the original array.\n * \n * @param fromIndex the start of the range (inclusive) to copy.\n * @param toIndex the end of the range (exclusive) to copy.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"} {"signature":"public actual fun DoubleArray . copyOfRange ( fromIndex : Int , toIndex : Int ) : DoubleArray","body":"{ checkCopyOfRangeArguments ( fromIndex , toIndex , size ) return copyOfUninitializedElements ( fromIndex , toIndex ) }","docstring":"/**\n * Returns a new array which is a copy of the specified range of the original array.\n * \n * @param fromIndex the start of the range (inclusive) to copy.\n * @param toIndex the end of the range (exclusive) to copy.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"} {"signature":"public actual fun BooleanArray . copyOfRange ( fromIndex : Int , toIndex : Int ) : BooleanArray","body":"{ checkCopyOfRangeArguments ( fromIndex , toIndex , size ) return copyOfUninitializedElements ( fromIndex , toIndex ) }","docstring":"/**\n * Returns a new array which is a copy of the specified range of the original array.\n * \n * @param fromIndex the start of the range (inclusive) to copy.\n * @param toIndex the end of the range (exclusive) to copy.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"} {"signature":"public actual fun CharArray . copyOfRange ( fromIndex : Int , toIndex : Int ) : CharArray","body":"{ checkCopyOfRangeArguments ( fromIndex , toIndex , size ) return copyOfUninitializedElements ( fromIndex , toIndex ) }","docstring":"/**\n * Returns a new array which is a copy of the specified range of the original array.\n * \n * @param fromIndex the start of the range (inclusive) to copy.\n * @param toIndex the end of the range (exclusive) to copy.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"} {"signature":"internal fun < T > Array < T > . copyOfUninitializedElements ( fromIndex : Int , toIndex : Int ) : Array < T >","body":"{ val newSize = toIndex - fromIndex if ( newSize < ) { throw IllegalArgumentException ( \"\" ) } val result = arrayOfUninitializedElements < T > ( newSize ) this . copyInto ( result , , fromIndex , toIndex . coerceAtMost ( size ) ) return result }","docstring":"/**\n * Returns new array which is a copy of the original array's range between [fromIndex] (inclusive)\n * and [toIndex] (exclusive) with new elements filled with **lateinit** _uninitialized_ values.\n * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,\n * either throwing exception or returning some kind of implementation-specific default value.\n */"} {"signature":"internal fun ByteArray . copyOfUninitializedElements ( fromIndex : Int , toIndex : Int ) : ByteArray","body":"{ val newSize = toIndex - fromIndex if ( newSize < ) { throw IllegalArgumentException ( \"\" ) } val result = ByteArray ( newSize ) this . copyInto ( result , , fromIndex , toIndex . coerceAtMost ( size ) ) return result }","docstring":"/**\n * Returns new array which is a copy of the original array's range between [fromIndex] (inclusive)\n * and [toIndex] (exclusive) with new elements filled with **lateinit** _uninitialized_ values.\n * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,\n * either throwing exception or returning some kind of implementation-specific default value.\n */"} {"signature":"internal fun ShortArray . copyOfUninitializedElements ( fromIndex : Int , toIndex : Int ) : ShortArray","body":"{ val newSize = toIndex - fromIndex if ( newSize < ) { throw IllegalArgumentException ( \"\" ) } val result = ShortArray ( newSize ) this . copyInto ( result , , fromIndex , toIndex . coerceAtMost ( size ) ) return result }","docstring":"/**\n * Returns new array which is a copy of the original array's range between [fromIndex] (inclusive)\n * and [toIndex] (exclusive) with new elements filled with **lateinit** _uninitialized_ values.\n * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,\n * either throwing exception or returning some kind of implementation-specific default value.\n */"} {"signature":"internal fun IntArray . copyOfUninitializedElements ( fromIndex : Int , toIndex : Int ) : IntArray","body":"{ val newSize = toIndex - fromIndex if ( newSize < ) { throw IllegalArgumentException ( \"\" ) } val result = IntArray ( newSize ) this . copyInto ( result , , fromIndex , toIndex . coerceAtMost ( size ) ) return result }","docstring":"/**\n * Returns new array which is a copy of the original array's range between [fromIndex] (inclusive)\n * and [toIndex] (exclusive) with new elements filled with **lateinit** _uninitialized_ values.\n * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,\n * either throwing exception or returning some kind of implementation-specific default value.\n */"} {"signature":"internal fun LongArray . copyOfUninitializedElements ( fromIndex : Int , toIndex : Int ) : LongArray","body":"{ val newSize = toIndex - fromIndex if ( newSize < ) { throw IllegalArgumentException ( \"\" ) } val result = LongArray ( newSize ) this . copyInto ( result , , fromIndex , toIndex . coerceAtMost ( size ) ) return result }","docstring":"/**\n * Returns new array which is a copy of the original array's range between [fromIndex] (inclusive)\n * and [toIndex] (exclusive) with new elements filled with **lateinit** _uninitialized_ values.\n * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,\n * either throwing exception or returning some kind of implementation-specific default value.\n */"} {"signature":"internal fun FloatArray . copyOfUninitializedElements ( fromIndex : Int , toIndex : Int ) : FloatArray","body":"{ val newSize = toIndex - fromIndex if ( newSize < ) { throw IllegalArgumentException ( \"\" ) } val result = FloatArray ( newSize ) this . copyInto ( result , , fromIndex , toIndex . coerceAtMost ( size ) ) return result }","docstring":"/**\n * Returns new array which is a copy of the original array's range between [fromIndex] (inclusive)\n * and [toIndex] (exclusive) with new elements filled with **lateinit** _uninitialized_ values.\n * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,\n * either throwing exception or returning some kind of implementation-specific default value.\n */"} {"signature":"internal fun DoubleArray . copyOfUninitializedElements ( fromIndex : Int , toIndex : Int ) : DoubleArray","body":"{ val newSize = toIndex - fromIndex if ( newSize < ) { throw IllegalArgumentException ( \"\" ) } val result = DoubleArray ( newSize ) this . copyInto ( result , , fromIndex , toIndex . coerceAtMost ( size ) ) return result }","docstring":"/**\n * Returns new array which is a copy of the original array's range between [fromIndex] (inclusive)\n * and [toIndex] (exclusive) with new elements filled with **lateinit** _uninitialized_ values.\n * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,\n * either throwing exception or returning some kind of implementation-specific default value.\n */"} {"signature":"internal fun BooleanArray . copyOfUninitializedElements ( fromIndex : Int , toIndex : Int ) : BooleanArray","body":"{ val newSize = toIndex - fromIndex if ( newSize < ) { throw IllegalArgumentException ( \"\" ) } val result = BooleanArray ( newSize ) this . copyInto ( result , , fromIndex , toIndex . coerceAtMost ( size ) ) return result }","docstring":"/**\n * Returns new array which is a copy of the original array's range between [fromIndex] (inclusive)\n * and [toIndex] (exclusive) with new elements filled with **lateinit** _uninitialized_ values.\n * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,\n * either throwing exception or returning some kind of implementation-specific default value.\n */"} {"signature":"internal fun CharArray . copyOfUninitializedElements ( fromIndex : Int , toIndex : Int ) : CharArray","body":"{ val newSize = toIndex - fromIndex if ( newSize < ) { throw IllegalArgumentException ( \"\" ) } val result = CharArray ( newSize ) this . copyInto ( result , , fromIndex , toIndex . coerceAtMost ( size ) ) return result }","docstring":"/**\n * Returns new array which is a copy of the original array's range between [fromIndex] (inclusive)\n * and [toIndex] (exclusive) with new elements filled with **lateinit** _uninitialized_ values.\n * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,\n * either throwing exception or returning some kind of implementation-specific default value.\n */"} {"signature":"internal fun < T > Array < T > . copyOfUninitializedElements ( newSize : Int ) : Array < T >","body":"{ return copyOfUninitializedElements ( , newSize ) }","docstring":"/**\n * Returns new array which is a copy of the original array with new elements filled with **lateinit** _uninitialized_ values.\n * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,\n * either throwing exception or returning some kind of implementation-specific default value.\n */"} {"signature":"internal fun ByteArray . copyOfUninitializedElements ( newSize : Int ) : ByteArray","body":"{ return copyOfUninitializedElements ( , newSize ) }","docstring":"/**\n * Returns new array which is a copy of the original array with new elements filled with **lateinit** _uninitialized_ values.\n * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,\n * either throwing exception or returning some kind of implementation-specific default value.\n */"} {"signature":"internal fun ShortArray . copyOfUninitializedElements ( newSize : Int ) : ShortArray","body":"{ return copyOfUninitializedElements ( , newSize ) }","docstring":"/**\n * Returns new array which is a copy of the original array with new elements filled with **lateinit** _uninitialized_ values.\n * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,\n * either throwing exception or returning some kind of implementation-specific default value.\n */"} {"signature":"internal fun IntArray . copyOfUninitializedElements ( newSize : Int ) : IntArray","body":"{ return copyOfUninitializedElements ( , newSize ) }","docstring":"/**\n * Returns new array which is a copy of the original array with new elements filled with **lateinit** _uninitialized_ values.\n * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,\n * either throwing exception or returning some kind of implementation-specific default value.\n */"} {"signature":"internal fun LongArray . copyOfUninitializedElements ( newSize : Int ) : LongArray","body":"{ return copyOfUninitializedElements ( , newSize ) }","docstring":"/**\n * Returns new array which is a copy of the original array with new elements filled with **lateinit** _uninitialized_ values.\n * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,\n * either throwing exception or returning some kind of implementation-specific default value.\n */"} {"signature":"internal fun FloatArray . copyOfUninitializedElements ( newSize : Int ) : FloatArray","body":"{ return copyOfUninitializedElements ( , newSize ) }","docstring":"/**\n * Returns new array which is a copy of the original array with new elements filled with **lateinit** _uninitialized_ values.\n * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,\n * either throwing exception or returning some kind of implementation-specific default value.\n */"} {"signature":"internal fun DoubleArray . copyOfUninitializedElements ( newSize : Int ) : DoubleArray","body":"{ return copyOfUninitializedElements ( , newSize ) }","docstring":"/**\n * Returns new array which is a copy of the original array with new elements filled with **lateinit** _uninitialized_ values.\n * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,\n * either throwing exception or returning some kind of implementation-specific default value.\n */"} {"signature":"internal fun BooleanArray . copyOfUninitializedElements ( newSize : Int ) : BooleanArray","body":"{ return copyOfUninitializedElements ( , newSize ) }","docstring":"/**\n * Returns new array which is a copy of the original array with new elements filled with **lateinit** _uninitialized_ values.\n * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,\n * either throwing exception or returning some kind of implementation-specific default value.\n */"} {"signature":"internal fun CharArray . copyOfUninitializedElements ( newSize : Int ) : CharArray","body":"{ return copyOfUninitializedElements ( , newSize ) }","docstring":"/**\n * Returns new array which is a copy of the original array with new elements filled with **lateinit** _uninitialized_ values.\n * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,\n * either throwing exception or returning some kind of implementation-specific default value.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" ) public actual fun < T > Array < T > . fill ( element : T , fromIndex : Int = , toIndex : Int = size ) : Unit","body":"{ arrayFill ( this , fromIndex , toIndex , element ) }","docstring":"/**\n * Fills this array or its subrange with the specified [element] value.\n * \n * @param fromIndex the start of the range (inclusive) to fill, 0 by default.\n * @param toIndex the end of the range (exclusive) to fill, size of this array by default.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" ) public actual fun ByteArray . fill ( element : Byte , fromIndex : Int = , toIndex : Int = size ) : Unit","body":"{ arrayFill ( this , fromIndex , toIndex , element ) }","docstring":"/**\n * Fills this array or its subrange with the specified [element] value.\n * \n * @param fromIndex the start of the range (inclusive) to fill, 0 by default.\n * @param toIndex the end of the range (exclusive) to fill, size of this array by default.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" ) public actual fun ShortArray . fill ( element : Short , fromIndex : Int = , toIndex : Int = size ) : Unit","body":"{ arrayFill ( this , fromIndex , toIndex , element ) }","docstring":"/**\n * Fills this array or its subrange with the specified [element] value.\n * \n * @param fromIndex the start of the range (inclusive) to fill, 0 by default.\n * @param toIndex the end of the range (exclusive) to fill, size of this array by default.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" ) public actual fun IntArray . fill ( element : Int , fromIndex : Int = , toIndex : Int = size ) : Unit","body":"{ arrayFill ( this , fromIndex , toIndex , element ) }","docstring":"/**\n * Fills this array or its subrange with the specified [element] value.\n * \n * @param fromIndex the start of the range (inclusive) to fill, 0 by default.\n * @param toIndex the end of the range (exclusive) to fill, size of this array by default.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" ) public actual fun LongArray . fill ( element : Long , fromIndex : Int = , toIndex : Int = size ) : Unit","body":"{ arrayFill ( this , fromIndex , toIndex , element ) }","docstring":"/**\n * Fills this array or its subrange with the specified [element] value.\n * \n * @param fromIndex the start of the range (inclusive) to fill, 0 by default.\n * @param toIndex the end of the range (exclusive) to fill, size of this array by default.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" ) public actual fun FloatArray . fill ( element : Float , fromIndex : Int = , toIndex : Int = size ) : Unit","body":"{ arrayFill ( this , fromIndex , toIndex , element ) }","docstring":"/**\n * Fills this array or its subrange with the specified [element] value.\n * \n * @param fromIndex the start of the range (inclusive) to fill, 0 by default.\n * @param toIndex the end of the range (exclusive) to fill, size of this array by default.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" ) public actual fun DoubleArray . fill ( element : Double , fromIndex : Int = , toIndex : Int = size ) : Unit","body":"{ arrayFill ( this , fromIndex , toIndex , element ) }","docstring":"/**\n * Fills this array or its subrange with the specified [element] value.\n * \n * @param fromIndex the start of the range (inclusive) to fill, 0 by default.\n * @param toIndex the end of the range (exclusive) to fill, size of this array by default.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" ) public actual fun BooleanArray . fill ( element : Boolean , fromIndex : Int = , toIndex : Int = size ) : Unit","body":"{ arrayFill ( this , fromIndex , toIndex , element ) }","docstring":"/**\n * Fills this array or its subrange with the specified [element] value.\n * \n * @param fromIndex the start of the range (inclusive) to fill, 0 by default.\n * @param toIndex the end of the range (exclusive) to fill, size of this array by default.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" ) public actual fun CharArray . fill ( element : Char , fromIndex : Int = , toIndex : Int = size ) : Unit","body":"{ arrayFill ( this , fromIndex , toIndex , element ) }","docstring":"/**\n * Fills this array or its subrange with the specified [element] value.\n * \n * @param fromIndex the start of the range (inclusive) to fill, 0 by default.\n * @param toIndex the end of the range (exclusive) to fill, size of this array by default.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"} {"signature":"public actual operator fun < T > Array < T > . plus ( element : T ) : Array < T >","body":"{ val index = size val result = copyOfUninitializedElements ( index + ) result [ index ] = element return result }","docstring":"/**\n * Returns an array containing all elements of the original array and then the given [element].\n */"} {"signature":"public actual operator fun ByteArray . plus ( element : Byte ) : ByteArray","body":"{ val index = size val result = copyOfUninitializedElements ( index + ) result [ index ] = element return result }","docstring":"/**\n * Returns an array containing all elements of the original array and then the given [element].\n */"} {"signature":"public actual operator fun ShortArray . plus ( element : Short ) : ShortArray","body":"{ val index = size val result = copyOfUninitializedElements ( index + ) result [ index ] = element return result }","docstring":"/**\n * Returns an array containing all elements of the original array and then the given [element].\n */"} {"signature":"public actual operator fun IntArray . plus ( element : Int ) : IntArray","body":"{ val index = size val result = copyOfUninitializedElements ( index + ) result [ index ] = element return result }","docstring":"/**\n * Returns an array containing all elements of the original array and then the given [element].\n */"} {"signature":"public actual operator fun LongArray . plus ( element : Long ) : LongArray","body":"{ val index = size val result = copyOfUninitializedElements ( index + ) result [ index ] = element return result }","docstring":"/**\n * Returns an array containing all elements of the original array and then the given [element].\n */"} {"signature":"public actual operator fun FloatArray . plus ( element : Float ) : FloatArray","body":"{ val index = size val result = copyOfUninitializedElements ( index + ) result [ index ] = element return result }","docstring":"/**\n * Returns an array containing all elements of the original array and then the given [element].\n */"} {"signature":"public actual operator fun DoubleArray . plus ( element : Double ) : DoubleArray","body":"{ val index = size val result = copyOfUninitializedElements ( index + ) result [ index ] = element return result }","docstring":"/**\n * Returns an array containing all elements of the original array and then the given [element].\n */"} {"signature":"public actual operator fun BooleanArray . plus ( element : Boolean ) : BooleanArray","body":"{ val index = size val result = copyOfUninitializedElements ( index + ) result [ index ] = element return result }","docstring":"/**\n * Returns an array containing all elements of the original array and then the given [element].\n */"} {"signature":"public actual operator fun CharArray . plus ( element : Char ) : CharArray","body":"{ val index = size val result = copyOfUninitializedElements ( index + ) result [ index ] = element return result }","docstring":"/**\n * Returns an array containing all elements of the original array and then the given [element].\n */"} {"signature":"public actual operator fun < T > Array < T > . plus ( elements : Collection < T > ) : Array < T >","body":"{ var index = size val result = copyOfUninitializedElements ( index + elements . size ) for ( element in elements ) result [ index ++ ] = element return result }","docstring":"/**\n * Returns an array containing all elements of the original array and then all elements of the given [elements] collection.\n */"} {"signature":"public actual operator fun ByteArray . plus ( elements : Collection < Byte > ) : ByteArray","body":"{ var index = size val result = copyOfUninitializedElements ( index + elements . size ) for ( element in elements ) result [ index ++ ] = element return result }","docstring":"/**\n * Returns an array containing all elements of the original array and then all elements of the given [elements] collection.\n */"} {"signature":"public actual operator fun ShortArray . plus ( elements : Collection < Short > ) : ShortArray","body":"{ var index = size val result = copyOfUninitializedElements ( index + elements . size ) for ( element in elements ) result [ index ++ ] = element return result }","docstring":"/**\n * Returns an array containing all elements of the original array and then all elements of the given [elements] collection.\n */"} {"signature":"public actual operator fun IntArray . plus ( elements : Collection < Int > ) : IntArray","body":"{ var index = size val result = copyOfUninitializedElements ( index + elements . size ) for ( element in elements ) result [ index ++ ] = element return result }","docstring":"/**\n * Returns an array containing all elements of the original array and then all elements of the given [elements] collection.\n */"} {"signature":"public actual operator fun LongArray . plus ( elements : Collection < Long > ) : LongArray","body":"{ var index = size val result = copyOfUninitializedElements ( index + elements . size ) for ( element in elements ) result [ index ++ ] = element return result }","docstring":"/**\n * Returns an array containing all elements of the original array and then all elements of the given [elements] collection.\n */"} {"signature":"public actual operator fun FloatArray . plus ( elements : Collection < Float > ) : FloatArray","body":"{ var index = size val result = copyOfUninitializedElements ( index + elements . size ) for ( element in elements ) result [ index ++ ] = element return result }","docstring":"/**\n * Returns an array containing all elements of the original array and then all elements of the given [elements] collection.\n */"} {"signature":"public actual operator fun DoubleArray . plus ( elements : Collection < Double > ) : DoubleArray","body":"{ var index = size val result = copyOfUninitializedElements ( index + elements . size ) for ( element in elements ) result [ index ++ ] = element return result }","docstring":"/**\n * Returns an array containing all elements of the original array and then all elements of the given [elements] collection.\n */"} {"signature":"public actual operator fun BooleanArray . plus ( elements : Collection < Boolean > ) : BooleanArray","body":"{ var index = size val result = copyOfUninitializedElements ( index + elements . size ) for ( element in elements ) result [ index ++ ] = element return result }","docstring":"/**\n * Returns an array containing all elements of the original array and then all elements of the given [elements] collection.\n */"} {"signature":"public actual operator fun CharArray . plus ( elements : Collection < Char > ) : CharArray","body":"{ var index = size val result = copyOfUninitializedElements ( index + elements . size ) for ( element in elements ) result [ index ++ ] = element return result }","docstring":"/**\n * Returns an array containing all elements of the original array and then all elements of the given [elements] collection.\n */"} {"signature":"public actual operator fun < T > Array < T > . plus ( elements : Array < out T > ) : Array < T >","body":"{ val thisSize = size val arraySize = elements . size val result = copyOfUninitializedElements ( thisSize + arraySize ) elements . copyInto ( result , thisSize ) return result }","docstring":"/**\n * Returns an array containing all elements of the original array and then all elements of the given [elements] array.\n */"} {"signature":"public actual operator fun ByteArray . plus ( elements : ByteArray ) : ByteArray","body":"{ val thisSize = size val arraySize = elements . size val result = copyOfUninitializedElements ( thisSize + arraySize ) elements . copyInto ( result , thisSize ) return result }","docstring":"/**\n * Returns an array containing all elements of the original array and then all elements of the given [elements] array.\n */"} {"signature":"public actual operator fun ShortArray . plus ( elements : ShortArray ) : ShortArray","body":"{ val thisSize = size val arraySize = elements . size val result = copyOfUninitializedElements ( thisSize + arraySize ) elements . copyInto ( result , thisSize ) return result }","docstring":"/**\n * Returns an array containing all elements of the original array and then all elements of the given [elements] array.\n */"} {"signature":"public actual operator fun IntArray . plus ( elements : IntArray ) : IntArray","body":"{ val thisSize = size val arraySize = elements . size val result = copyOfUninitializedElements ( thisSize + arraySize ) elements . copyInto ( result , thisSize ) return result }","docstring":"/**\n * Returns an array containing all elements of the original array and then all elements of the given [elements] array.\n */"} {"signature":"public actual operator fun LongArray . plus ( elements : LongArray ) : LongArray","body":"{ val thisSize = size val arraySize = elements . size val result = copyOfUninitializedElements ( thisSize + arraySize ) elements . copyInto ( result , thisSize ) return result }","docstring":"/**\n * Returns an array containing all elements of the original array and then all elements of the given [elements] array.\n */"} {"signature":"public actual operator fun FloatArray . plus ( elements : FloatArray ) : FloatArray","body":"{ val thisSize = size val arraySize = elements . size val result = copyOfUninitializedElements ( thisSize + arraySize ) elements . copyInto ( result , thisSize ) return result }","docstring":"/**\n * Returns an array containing all elements of the original array and then all elements of the given [elements] array.\n */"} {"signature":"public actual operator fun DoubleArray . plus ( elements : DoubleArray ) : DoubleArray","body":"{ val thisSize = size val arraySize = elements . size val result = copyOfUninitializedElements ( thisSize + arraySize ) elements . copyInto ( result , thisSize ) return result }","docstring":"/**\n * Returns an array containing all elements of the original array and then all elements of the given [elements] array.\n */"} {"signature":"public actual operator fun BooleanArray . plus ( elements : BooleanArray ) : BooleanArray","body":"{ val thisSize = size val arraySize = elements . size val result = copyOfUninitializedElements ( thisSize + arraySize ) elements . copyInto ( result , thisSize ) return result }","docstring":"/**\n * Returns an array containing all elements of the original array and then all elements of the given [elements] array.\n */"} {"signature":"public actual operator fun CharArray . plus ( elements : CharArray ) : CharArray","body":"{ val thisSize = size val arraySize = elements . size val result = copyOfUninitializedElements ( thisSize + arraySize ) elements . copyInto ( result , thisSize ) return result }","docstring":"/**\n * Returns an array containing all elements of the original array and then all elements of the given [elements] array.\n */"} {"signature":"@ kotlin . internal . InlineOnly public actual inline fun < T > Array < T > . plusElement ( element : T ) : Array < T >","body":"{ return plus ( element ) }","docstring":"/**\n * Returns an array containing all elements of the original array and then the given [element].\n */"} {"signature":"public actual fun IntArray . sort ( ) : Unit","body":"{ if ( size > ) sortArray ( this , , size ) }","docstring":"/**\n * Sorts the array in-place.\n * \n * @sample samples.collections.Arrays.Sorting.sortArray\n */"} {"signature":"public actual fun LongArray . sort ( ) : Unit","body":"{ if ( size > ) sortArray ( this , , size ) }","docstring":"/**\n * Sorts the array in-place.\n * \n * @sample samples.collections.Arrays.Sorting.sortArray\n */"} {"signature":"public actual fun ByteArray . sort ( ) : Unit","body":"{ if ( size > ) sortArray ( this , , size ) }","docstring":"/**\n * Sorts the array in-place.\n * \n * @sample samples.collections.Arrays.Sorting.sortArray\n */"} {"signature":"public actual fun ShortArray . sort ( ) : Unit","body":"{ if ( size > ) sortArray ( this , , size ) }","docstring":"/**\n * Sorts the array in-place.\n * \n * @sample samples.collections.Arrays.Sorting.sortArray\n */"} {"signature":"public actual fun DoubleArray . sort ( ) : Unit","body":"{ if ( size > ) sortArray ( this , , size ) }","docstring":"/**\n * Sorts the array in-place.\n * \n * @sample samples.collections.Arrays.Sorting.sortArray\n */"} {"signature":"public actual fun FloatArray . sort ( ) : Unit","body":"{ if ( size > ) sortArray ( this , , size ) }","docstring":"/**\n * Sorts the array in-place.\n * \n * @sample samples.collections.Arrays.Sorting.sortArray\n */"} {"signature":"public actual fun CharArray . sort ( ) : Unit","body":"{ if ( size > ) sortArray ( this , , size ) }","docstring":"/**\n * Sorts the array in-place.\n * \n * @sample samples.collections.Arrays.Sorting.sortArray\n */"} {"signature":"public actual fun < T : Comparable < T > > Array < out T > . sort ( ) : Unit","body":"{ if ( size > ) sortArray ( this , , size ) }","docstring":"/**\n * Sorts the array in-place according to the natural order of its elements.\n * \n * The sort is _stable_. It means that equal elements preserve their order relative to each other after sorting.\n * \n * @sample samples.collections.Arrays.Sorting.sortArrayOfComparable\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" ) public actual fun < T : Comparable < T > > Array < out T > . sort ( fromIndex : Int = , toIndex : Int = size ) : Unit","body":"{ AbstractList . checkRangeIndexes ( fromIndex , toIndex , size ) sortArray ( this , fromIndex , toIndex ) }","docstring":"/**\n * Sorts a range in the array in-place.\n * \n * The sort is _stable_. It means that equal elements preserve their order relative to each other after sorting.\n * \n * @param fromIndex the start of the range (inclusive) to sort, 0 by default.\n * @param toIndex the end of the range (exclusive) to sort, size of this array by default.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n * \n * @sample samples.collections.Arrays.Sorting.sortRangeOfArrayOfComparable\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" ) public actual fun ByteArray . sort ( fromIndex : Int = , toIndex : Int = size ) : Unit","body":"{ AbstractList . checkRangeIndexes ( fromIndex , toIndex , size ) sortArray ( this , fromIndex , toIndex ) }","docstring":"/**\n * Sorts a range in the array in-place.\n * \n * @param fromIndex the start of the range (inclusive) to sort, 0 by default.\n * @param toIndex the end of the range (exclusive) to sort, size of this array by default.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n * \n * @sample samples.collections.Arrays.Sorting.sortRangeOfArray\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" ) public actual fun ShortArray . sort ( fromIndex : Int = , toIndex : Int = size ) : Unit","body":"{ AbstractList . checkRangeIndexes ( fromIndex , toIndex , size ) sortArray ( this , fromIndex , toIndex ) }","docstring":"/**\n * Sorts a range in the array in-place.\n * \n * @param fromIndex the start of the range (inclusive) to sort, 0 by default.\n * @param toIndex the end of the range (exclusive) to sort, size of this array by default.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n * \n * @sample samples.collections.Arrays.Sorting.sortRangeOfArray\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" ) public actual fun IntArray . sort ( fromIndex : Int = , toIndex : Int = size ) : Unit","body":"{ AbstractList . checkRangeIndexes ( fromIndex , toIndex , size ) sortArray ( this , fromIndex , toIndex ) }","docstring":"/**\n * Sorts a range in the array in-place.\n * \n * @param fromIndex the start of the range (inclusive) to sort, 0 by default.\n * @param toIndex the end of the range (exclusive) to sort, size of this array by default.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n * \n * @sample samples.collections.Arrays.Sorting.sortRangeOfArray\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" ) public actual fun LongArray . sort ( fromIndex : Int = , toIndex : Int = size ) : Unit","body":"{ AbstractList . checkRangeIndexes ( fromIndex , toIndex , size ) sortArray ( this , fromIndex , toIndex ) }","docstring":"/**\n * Sorts a range in the array in-place.\n * \n * @param fromIndex the start of the range (inclusive) to sort, 0 by default.\n * @param toIndex the end of the range (exclusive) to sort, size of this array by default.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n * \n * @sample samples.collections.Arrays.Sorting.sortRangeOfArray\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" ) public actual fun FloatArray . sort ( fromIndex : Int = , toIndex : Int = size ) : Unit","body":"{ AbstractList . checkRangeIndexes ( fromIndex , toIndex , size ) sortArray ( this , fromIndex , toIndex ) }","docstring":"/**\n * Sorts a range in the array in-place.\n * \n * @param fromIndex the start of the range (inclusive) to sort, 0 by default.\n * @param toIndex the end of the range (exclusive) to sort, size of this array by default.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n * \n * @sample samples.collections.Arrays.Sorting.sortRangeOfArray\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" ) public actual fun DoubleArray . sort ( fromIndex : Int = , toIndex : Int = size ) : Unit","body":"{ AbstractList . checkRangeIndexes ( fromIndex , toIndex , size ) sortArray ( this , fromIndex , toIndex ) }","docstring":"/**\n * Sorts a range in the array in-place.\n * \n * @param fromIndex the start of the range (inclusive) to sort, 0 by default.\n * @param toIndex the end of the range (exclusive) to sort, size of this array by default.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n * \n * @sample samples.collections.Arrays.Sorting.sortRangeOfArray\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" ) public actual fun CharArray . sort ( fromIndex : Int = , toIndex : Int = size ) : Unit","body":"{ AbstractList . checkRangeIndexes ( fromIndex , toIndex , size ) sortArray ( this , fromIndex , toIndex ) }","docstring":"/**\n * Sorts a range in the array in-place.\n * \n * @param fromIndex the start of the range (inclusive) to sort, 0 by default.\n * @param toIndex the end of the range (exclusive) to sort, size of this array by default.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n * \n * @sample samples.collections.Arrays.Sorting.sortRangeOfArray\n */"} {"signature":"public actual fun < T > Array < out T > . sortWith ( comparator : Comparator < in T > ) : Unit","body":"{ if ( size > ) sortArrayWith ( this , , size , comparator ) }","docstring":"/**\n * Sorts the array in-place according to the order specified by the given [comparator].\n * \n * The sort is _stable_. It means that equal elements preserve their order relative to each other after sorting.\n */"} {"signature":"@ Suppress ( \"\" ) public actual fun < T > Array < out T > . sortWith ( comparator : Comparator < in T > , fromIndex : Int = , toIndex : Int = size ) : Unit","body":"{ AbstractList . checkRangeIndexes ( fromIndex , toIndex , size ) sortArrayWith ( this , fromIndex , toIndex , comparator ) }","docstring":"/**\n * Sorts a range in the array in-place with the given [comparator].\n * \n * The sort is _stable_. It means that equal elements preserve their order relative to each other after sorting.\n * \n * @param fromIndex the start of the range (inclusive) to sort, 0 by default.\n * @param toIndex the end of the range (exclusive) to sort, size of this array by default.\n * \n * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].\n */"} {"signature":"public actual fun ByteArray . toTypedArray ( ) : Array < Byte >","body":"{ return Array ( size ) { index -> this [ index ] } }","docstring":"/**\n * Returns a *typed* object array containing all of the elements of this primitive array.\n */"} {"signature":"public actual fun ShortArray . toTypedArray ( ) : Array < Short >","body":"{ return Array ( size ) { index -> this [ index ] } }","docstring":"/**\n * Returns a *typed* object array containing all of the elements of this primitive array.\n */"} {"signature":"public actual fun IntArray . toTypedArray ( ) : Array < Int >","body":"{ return Array ( size ) { index -> this [ index ] } }","docstring":"/**\n * Returns a *typed* object array containing all of the elements of this primitive array.\n */"} {"signature":"public actual fun LongArray . toTypedArray ( ) : Array < Long >","body":"{ return Array ( size ) { index -> this [ index ] } }","docstring":"/**\n * Returns a *typed* object array containing all of the elements of this primitive array.\n */"} {"signature":"public actual fun FloatArray . toTypedArray ( ) : Array < Float >","body":"{ return Array ( size ) { index -> this [ index ] } }","docstring":"/**\n * Returns a *typed* object array containing all of the elements of this primitive array.\n */"} {"signature":"public actual fun DoubleArray . toTypedArray ( ) : Array < Double >","body":"{ return Array ( size ) { index -> this [ index ] } }","docstring":"/**\n * Returns a *typed* object array containing all of the elements of this primitive array.\n */"} {"signature":"public actual fun BooleanArray . toTypedArray ( ) : Array < Boolean >","body":"{ return Array ( size ) { index -> this [ index ] } }","docstring":"/**\n * Returns a *typed* object array containing all of the elements of this primitive array.\n */"} {"signature":"public actual fun CharArray . toTypedArray ( ) : Array < Char >","body":"{ return Array ( size ) { index -> this [ index ] } }","docstring":"/**\n * Returns a *typed* object array containing all of the elements of this primitive array.\n */"} {"signature":"fun remember ( from : KotlinSourceSet , to : KotlinSourceSet )","body":"{ if ( dontRemember ) return rememberedEdges . add ( from to to ) }","docstring":"/** Should be called from [KotlinSourceSet.dependsOn] method,\n * so depends on edges are tracked and can be distinguished when they added via [addDependsOnEdgeFromTemplate] */"} {"signature":"private fun tryExpandExpectNestedClassActualizedViaTypealias ( expectNestedClassType : ConeClassLikeType , expectNestedClassSymbol : FirRegularClassSymbol , ) : ConeClassLikeType ?","body":"{ val expectNestedClassId = expectNestedClassSymbol . classId val expectOutermostClassId = expectNestedClassId . outermostClassId val actualTypealiasSymbol = expectOutermostClassId . toSymbol ( actualSession ) as? FirTypeAliasSymbol ? : return null val actualOutermostClassId = actualTypealiasSymbol . fullyExpandedClass ( actualSession ) ? . classId ? : return null val actualNestedClassId = ClassId . fromString ( expectNestedClassId . asString ( ) . replaceFirst ( expectOutermostClassId . asString ( ) , actualOutermostClassId . asString ( ) ) ) return actualNestedClassId . constructClassLikeType ( expectNestedClassType . typeArguments , expectNestedClassType . isNullable , expectNestedClassType . attributes ) }","docstring":"/**\n * In case of `expect` nested classes actualized via typealias we can't simply find actual symbol by `expect` `ClassId`\n * (like we do for top-level classes), because `ClassId` is different.\n * For example, `expect` class `com/example/ExpectClass.Nested` may have actual with id `real/package/ActualTypeliasTarget.Nested`.\n * So, we first expand outermost class, and then construct `ClassId` for nested class.\n */"} {"signature":"fun foo ( p : Int , p2 : Double ) : Short","body":"= ","docstring":"/**\n * Function foo description\n *\n * @param p first Integer to consume\n * @param p2 second Double to consume\n * @return Short, constant 1\n */"} {"signature":"@ Test fun sample ( )","body":"{ val testProject = mixedJvmTestProject { dokkaConfiguration { moduleName = \"\" jvmSourceSet { } } kotlinSourceDirectory { ktFile ( pathFromSrc = \"\" ) { + \"\" } javaFile ( pathFromSrc = \"\" ) { + \"\"\"\"\"\" } } javaSourceDirectory { ktFile ( pathFromSrc = \"\" ) { + \"\" } javaFile ( pathFromSrc = \"\" ) { + \"\"\"\"\"\" } } } val module = testProject . parse ( ) assertEquals ( \"\" , module . name ) assertEquals ( , module . packages . size ) val pckg = module . packages [ ] assertEquals ( \"\" , pckg . name ) assertEquals ( , pckg . classlikes . size ) assertEquals ( , pckg . functions . size ) val firstClasslike = pckg . classlikes [ ] assertEquals ( \"\" , firstClasslike . name ) val secondClasslike = pckg . classlikes [ ] assertEquals ( \"\" , secondClasslike . name ) val functions = pckg . functions . sortedBy { it . name } val firstFunction = functions [ ] assertEquals ( \"\" , firstFunction . name ) val secondFunction = functions [ ] assertEquals ( \"\" , secondFunction . name ) }","docstring":"/**\n * Used as a sample for [mixedJvmTestProject]\n */"} {"signature":"fun < T > DataStreamWriter < T > . forEachBatch ( func : ( batch : Dataset < T > , batchId : Long ) -> Unit , ) : DataStreamWriter < T >","body":"= foreachBatch ( VoidFunction2 ( func ) )","docstring":"/**\n * :: Experimental ::\n *\n * (Scala-specific) Sets the output of the streaming query to be processed using the provided\n * function. This is supported only in the micro-batch execution modes (that is, when the\n * trigger is not continuous). In every micro-batch, the provided function will be called in\n * every micro-batch with (i) the output rows as a Dataset and (ii) the batch identifier.\n * The batchId can be used to deduplicate and transactionally write the output\n * (that is, the provided Dataset) to external systems. The output Dataset is guaranteed\n * to be exactly the same for the same batchId (assuming all operations are deterministic\n * in the query).\n *\n * @since 2.4.0\n */"} {"signature":"public suspend fun < T > runInterruptible ( context : CoroutineContext = EmptyCoroutineContext , block : ( ) -> T ) : T","body":"= withContext ( context ) { runInterruptibleInExpectedContext ( coroutineContext , block ) }","docstring":"/**\n * Calls the specified [block] with a given coroutine context in\n * [an interruptible manner](https://docs.oracle.com/javase/tutorial/essential/concurrency/interrupt.html).\n * The blocking code block will be interrupted and this function will throw [CancellationException]\n * if the coroutine is cancelled.\n *\n * Example:\n *\n * ```\n * withTimeout(500L) { // Cancels coroutine on timeout\n * runInterruptible { // Throws CancellationException if interrupted\n * doSomethingBlocking() // Interrupted on coroutines cancellation\n * }\n * }\n * ```\n *\n * There is an optional [context] parameter to this function working just like [withContext].\n * It enables single-call conversion of interruptible Java methods into suspending functions.\n * With one call here we are moving the call to [Dispatchers.IO] and supporting interruption:\n *\n * ```\n * suspend fun BlockingQueue.awaitTake(): T =\n * runInterruptible(Dispatchers.IO) { queue.take() }\n * ```\n *\n * `runInterruptible` uses [withContext] as an underlying mechanism for switching context,\n * meaning that the supplied [block] is invoked in an [undispatched][CoroutineStart.UNDISPATCHED]\n * manner directly by the caller if [CoroutineDispatcher] from the current [coroutineContext][currentCoroutineContext]\n * is the same as the one supplied in [context].\n */"} {"signature":"public fun < T > xBegin ( column : ColumnReference < T > ) : PositionalMapping < T >","body":"{ return addPositionalMapping < T > ( X_BEGIN , column . name ( ) , null ) }","docstring":"/**\n * Maps the `xBegin` aesthetic to a data column by [ColumnReference].\n *\n * @param column the data column to be mapped.\n * @return a [PositionalMapping] object representing the mapping.\n */"} {"signature":"public fun < T > xBegin ( column : KProperty < T > ) : PositionalMapping < T >","body":"{ return addPositionalMapping < T > ( X_BEGIN , column . name , null ) }","docstring":"/**\n * Maps the `xBegin` aesthetic to a data column by [KProperty].\n *\n * @param column the data column to be mapped.\n * @return a [PositionalMapping] object representing the mapping.\n */"} {"signature":"public fun xBegin ( column : String ) : PositionalMapping < Any ? >","body":"{ return addPositionalMapping ( X_BEGIN , column , null ) }","docstring":"/**\n * Maps the `xBegin` aesthetic to a data column by [String].\n *\n * @param column the data column to be mapped.\n * @return a [PositionalMapping] object representing the mapping.\n */"} {"signature":"public fun < T > xBegin ( values : Iterable < T > ) : PositionalMapping < T >","body":"{ return addPositionalMapping < T > ( X_BEGIN , values . toList ( ) , null , null ) }","docstring":"/**\n * Maps the `xBegin` aesthetic to iterable of values.\n *\n * @param values the iterable of values to be mapped.\n * @return a [PositionalMapping] object representing the mapping.\n */"} {"signature":"public fun < T > xBegin ( values : DataColumn < T > ) : PositionalMapping < T >","body":"{ return addPositionalMapping < T > ( X_BEGIN , values , null ) }","docstring":"/**\n * Maps the `xBegin` aesthetic to a data column.\n *\n * @param values the data column to be mapped.\n * @return a [PositionalMapping] object representing the mapping.\n */"} {"signature":"public fun getLabel ( dataSource : D ) : Float","body":"public fun getLabel ( dataSource : D ) : Float","docstring":"/**\n * Returns a label for provided [dataSource].\n */"} {"signature":"fun List < FirAnnotation > . computeTypeAttributes ( session : FirSession , predefined : List < ConeAttribute < * > > = emptyList ( ) , allowExtensionFunctionType : Boolean = true , shouldExpandTypeAliases : Boolean ) : ConeAttributes","body":"{ if ( this . isEmpty ( ) ) { if ( predefined . isEmpty ( ) ) return ConeAttributes . Empty return ConeAttributes . create ( predefined ) } val attributes = mutableListOf < ConeAttribute < * > > ( ) attributes += predefined val customAnnotations = mutableListOf < FirAnnotation > ( ) for ( annotation in this ) { val classId = when ( shouldExpandTypeAliases ) { true -> annotation . tryExpandClassId ( session ) false -> annotation . resolvedType . classId } when ( classId ) { CompilerConeAttributes . Exact . ANNOTATION_CLASS_ID -> attributes += CompilerConeAttributes . Exact CompilerConeAttributes . NoInfer . ANNOTATION_CLASS_ID -> attributes += CompilerConeAttributes . NoInfer CompilerConeAttributes . ExtensionFunctionType . ANNOTATION_CLASS_ID -> when { allowExtensionFunctionType -> attributes += CompilerConeAttributes . ExtensionFunctionType } CompilerConeAttributes . ContextFunctionTypeParams . ANNOTATION_CLASS_ID -> attributes += CompilerConeAttributes . ContextFunctionTypeParams ( annotation . extractContextReceiversCount ( ) ? : ) CompilerConeAttributes . UnsafeVariance . ANNOTATION_CLASS_ID -> attributes += CompilerConeAttributes . UnsafeVariance else -> { val attributeFromPlugin = session . extensionService . typeAttributeExtensions . firstNotNullOfOrNull { it . extractAttributeFromAnnotation ( annotation ) } if ( attributeFromPlugin != null ) { attributes += attributeFromPlugin } else { customAnnotations += annotation } } } } if ( customAnnotations . isNotEmpty ( ) ) { attributes += CustomAnnotationTypeAttribute ( customAnnotations ) } return ConeAttributes . create ( attributes ) }","docstring":"/**\n * [shouldExpandTypeAliases] should be set to `false` if this function is called during deserialization of some binary declaration\n * For details see KT-57876\n */"} {"signature":"@ ExperimentalKotlinGradlePluginApi fun compilerOptions ( configure : CO . ( ) -> Unit )","body":"{ configure ( compilerOptions ) }","docstring":"/**\n * Configures the [compilerOptions] with the provided configuration.\n */"} {"signature":"@ ExperimentalKotlinGradlePluginApi fun compilerOptions ( configure : Action < CO > )","body":"{ configure . execute ( compilerOptions ) }","docstring":"/**\n * Configures the [compilerOptions] with the provided configuration.\n */"} {"signature":"@ TestOnly public abstract fun publishGlobalModuleStateModification ( )","body":"@ TestOnly public abstract fun publishGlobalModuleStateModification ( )","docstring":"/**\n * Publishes an event of global modification of the module state of all [KtModule]s.\n */"} {"signature":"@ TestOnly public abstract fun publishGlobalSourceModuleStateModification ( )","body":"@ TestOnly public abstract fun publishGlobalSourceModuleStateModification ( )","docstring":"/**\n * Publishes an event of global modification of the module state of all source [KtModule]s.\n */"} {"signature":"@ TestOnly public abstract fun publishGlobalSourceOutOfBlockModification ( )","body":"@ TestOnly public abstract fun publishGlobalSourceOutOfBlockModification ( )","docstring":"/**\n * Publishes an event of global out-of-block modification of all source [KtModule]s. The event does not invalidate module state like\n * [publishGlobalSourceModuleStateModification], so some module structure-specific caches might persist.\n */"} {"signature":"public fun isOpenApiStr ( text : String ) : Boolean","body":"= try { val parsed = OpenAPIParser ( ) . readContents ( text , null , null ) parsed . openAPI ? . components ? . schemas != null } catch ( e : Throwable ) { logger . debug ( e ) { \"\" } false }","docstring":"/** Needs to have any type schemas to convert. */"} {"signature":"public abstract fun getKtFiles ( ) : List < KtResolveExtensionFile >","body":"public abstract fun getKtFiles ( ) : List < KtResolveExtensionFile >","docstring":"/**\n * Get the list of files that should be generated for the module. Returned files should contain valid Kotlin code.\n *\n * If the content of these files becomes invalid (e.g., because the source declarations they were based on changed), the\n * [KtResolveExtension] must publish an out-of-block modification event via the Analysis API message bus:\n * [org.jetbrains.kotlin.analysis.providers.topics.KotlinTopics.MODULE_OUT_OF_BLOCK_MODIFICATION].\n *\n * To react to changes in Kotlin sources, [KtResolveExtension] may subscribe to Analysis API topics:\n * [org.jetbrains.kotlin.analysis.providers.topics.KotlinTopics]. If the [KtResolveExtension] both subscribes to and\n * publishes modification events, care needs to be taken that no cycles are introduced. In general, the [KtResolveExtension] should\n * never publish an event for a module A in a listener for the same module A.\n *\n * An out-of-block modification event for the [KtResolveExtension]'s associated module does not need to be published in response to an\n * out-of-block modification event for the same module, because the original event suffices for invalidation.\n *\n * @see KtResolveExtensionFile\n * @see KtResolveExtension\n */"} {"signature":"public abstract fun getContainedPackages ( ) : Set < FqName >","body":"public abstract fun getContainedPackages ( ) : Set < FqName >","docstring":"/**\n * Returns the set of packages that are contained in the files provided by [getKtFiles].\n *\n * The returned package set should be a strict set of all file packages,\n * so `for-all pckg: pckg in getContainedPackages() <=> exists file: file in getKtFiles() && file.getFilePackageName() == pckg`\n *\n * @see KtResolveExtension\n */"} {"signature":"public open fun getShadowedScope ( ) : GlobalSearchScope","body":"= GlobalSearchScope . EMPTY_SCOPE","docstring":"/**\n * Returns the scope of files that should be shadowed by the files provided by [getKtFiles].\n *\n * Any files in the module that are included in this scope will be removed from analysis results. This allows the files provided by\n * [getKtFiles] to cleanly replace those files from the module.\n *\n * If this resolve extension is being used to generate declarations that would normally be provided by sources generated by an external\n * build task, such as a resource compiler or annotation processor, the resolve extension should provide a scope here that covers those\n * externally generated sources. This will prevent collisions between the definitions provided by [getKtFiles] and those provided by the\n * (potentially stale) externally generated sources.\n */"} {"signature":"@ kotlin . internal . InlineOnly public inline fun < T > Lock . withLock ( action : ( ) -> T ) : T","body":"{ contract { callsInPlace ( action , InvocationKind . EXACTLY_ONCE ) } lock ( ) try { return action ( ) } finally { unlock ( ) } }","docstring":"/**\n * Executes the given [action] under this lock.\n * @return the return value of the action.\n */"} {"signature":"@ kotlin . internal . InlineOnly public inline fun < T > ReentrantReadWriteLock . read ( action : ( ) -> T ) : T","body":"{ contract { callsInPlace ( action , InvocationKind . EXACTLY_ONCE ) } val rl = readLock ( ) rl . lock ( ) try { return action ( ) } finally { rl . unlock ( ) } }","docstring":"/**\n * Executes the given [action] under the read lock of this lock.\n * @return the return value of the action.\n */"} {"signature":"@ kotlin . internal . InlineOnly public inline fun < T > ReentrantReadWriteLock . write ( action : ( ) -> T ) : T","body":"{ contract { callsInPlace ( action , InvocationKind . EXACTLY_ONCE ) } val rl = readLock ( ) val readCount = if ( writeHoldCount == ) readHoldCount else repeat ( readCount ) { rl . unlock ( ) } val wl = writeLock ( ) wl . lock ( ) try { return action ( ) } finally { repeat ( readCount ) { rl . lock ( ) } wl . unlock ( ) } }","docstring":"/**\n * Executes the given [action] under the write lock of this lock.\n *\n * The function does upgrade from read to write lock if needed, but this upgrade is not atomic\n * as such upgrade is not supported by [ReentrantReadWriteLock].\n * In order to do such upgrade this function first releases all read locks held by this thread,\n * then acquires write lock, and after releasing it acquires read locks back again.\n *\n * Therefore if the [action] inside write lock has been initiated by checking some condition,\n * the condition must be rechecked inside the [action] to avoid possible races.\n *\n * @return the return value of the action.\n */"} {"signature":"public abstract fun hasAnnotation ( classId : ClassId , useSiteTargetFilter : AnnotationUseSiteTargetFilter = AnyAnnotationUseSiteTargetFilter , ) : Boolean","body":"public abstract fun hasAnnotation ( classId : ClassId , useSiteTargetFilter : AnnotationUseSiteTargetFilter = AnyAnnotationUseSiteTargetFilter , ) : Boolean","docstring":"/**\n * Checks if entity contains annotation with specified [classId] and filtered by [useSiteTargetFilter].\n *\n * The semantic is equivalent to\n * ```\n * annotationsList.hasAnnotation(classId, useSiteTargetFilter) == annotationsList.annotations.any {\n * it.classId == classId && useSiteTargetFilter.isAllowed(it.useSiteTarget)\n * }\n * ```\n * @param classId [ClassId] to search\n * @param useSiteTargetFilter specific [AnnotationUseSiteTargetFilter]\n */"} {"signature":"public abstract fun annotationsByClassId ( classId : ClassId , useSiteTargetFilter : AnnotationUseSiteTargetFilter = AnyAnnotationUseSiteTargetFilter , ) : List < KtAnnotationApplicationWithArgumentsInfo >","body":"public abstract fun annotationsByClassId ( classId : ClassId , useSiteTargetFilter : AnnotationUseSiteTargetFilter = AnyAnnotationUseSiteTargetFilter , ) : List < KtAnnotationApplicationWithArgumentsInfo >","docstring":"/**\n * A list of annotations applied with specified [classId] and filtered by [useSiteTargetFilter].\n *\n * To check if annotation is present, please use [hasAnnotation].\n *\n * The semantic is equivalent to\n * ```\n * annotationsList.annotationsByClassId(classId) == annotationsList.annotations.filter {\n * it.classId == classId && useSiteTargetFilter.isAllowed(it.useSiteTarget)\n * }\n * ```\n *\n * @see KtAnnotationApplicationWithArgumentsInfo\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" , \"\" ) public expect fun CancellationException ( message : String ? , cause : Throwable ? ) : CancellationException","body":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" , \"\" ) public expect fun CancellationException ( message : String ? , cause : Throwable ? ) : CancellationException","docstring":"/**\n * Creates an instance of [CancellationException] with the given [message] and [cause].\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" , \"\" ) public expect fun CancellationException ( cause : Throwable ? ) : CancellationException","body":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" , \"\" ) public expect fun CancellationException ( cause : Throwable ? ) : CancellationException","docstring":"/**\n * Creates an instance of [CancellationException] with the given [cause].\n */"} {"signature":"public fun map ( mapping : ( Float , Float ) -> Pair < Float , Float > ) : T","body":"public fun map ( mapping : ( Float , Float ) -> Pair < Float , Float > ) : T","docstring":"/**\n * Creates a new geometric shape of the same type by applying the provided [mapping]\n * to the coordinates of the current shape.\n */"} {"signature":"public fun KtDeclarationSymbol . render ( renderer : KtDeclarationRenderer = KtDeclarationRendererForSource . WITH_QUALIFIED_NAMES ) : String","body":"= withValidityAssertion { analysisSession . symbolDeclarationRendererProvider . renderDeclaration ( this , renderer ) }","docstring":"/**\n * Render symbol into the representable Kotlin string\n */"} {"signature":"public fun KtType . render ( renderer : KtTypeRenderer = KtTypeRendererForSource . WITH_QUALIFIED_NAMES , position : Variance , ) : String","body":"= withValidityAssertion { analysisSession . symbolDeclarationRendererProvider . renderType ( this , renderer , position ) }","docstring":"/**\n * Render kotlin type into the representable Kotlin type string\n */"} {"signature":"public fun < C > String . colsOf ( type : KType , filter : ColumnFilter < C > = { true } , ) : ColumnSet < * >","body":"= columnGroup ( this ) . colsOf ( type , filter )","docstring":"/**\n * @include [CommonColsOfDocs]\n *\n * `df.`[select][DataFrame.select]` { \"myColumnGroup\".`[colsOf][String.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) }`\n *\n * `df.`[select][DataFrame.select]` { \"myColumnGroup\".`[colsOf][String.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) { it: `[DataColumn][DataColumn]`<`[Int][Int]`> -> it.`[size][DataColumn.size]` > 10 } }`\n *\n * @include [CommonColsOfDocs.FilterParam]\n * @include [CommonColsOfDocs.Return]\n */"} {"signature":"public fun < C > KProperty < * > . colsOf ( type : KType , filter : ColumnFilter < C > = { true } , ) : ColumnSet < * >","body":"= columnGroup ( this ) . colsOf ( type , filter )","docstring":"/**\n * @include [CommonColsOfDocs]\n *\n * `df.`[select][DataFrame.select]` { DataSchemaType::myColumnGroup.`[colsOf][KProperty.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) }`\n *\n * `df.`[select][DataFrame.select]` { Type::myColumnGroup.`[colsOf][KProperty.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) { it: `[DataColumn][DataColumn]`<`[Int][Int]`> -> it.`[size][DataColumn.size]` > 10 } }`\n *\n * @include [CommonColsOfDocs.FilterParam]\n * @include [CommonColsOfDocs.Return]\n */"} {"signature":"public fun < C > ColumnPath . colsOf ( type : KType , filter : ColumnFilter < C > = { true } , ) : ColumnSet < * >","body":"= columnGroup ( this ) . colsOf ( type , filter )","docstring":"/**\n * @include [CommonColsOfDocs]\n *\n * `df.`[select][DataFrame.select]` { \"pathTo\"[\"myColumnGroup\"].`[colsOf][ColumnPath.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) }`\n *\n * `df.`[select][DataFrame.select]` { \"pathTo\"[\"myColumnGroup\"].`[colsOf][ColumnPath.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) { it: `[DataColumn][DataColumn]`<`[Int][Int]`> -> it.`[size][DataColumn.size]` > 10 } }`\n *\n * @include [CommonColsOfDocs.FilterParam]\n * @include [CommonColsOfDocs.Return]\n */"} {"signature":"public fun < C > ColumnSet < * > . colsOf ( type : KType , filter : ColumnFilter < C > = { true } , ) : TransformableColumnSet < C >","body":"= colsOfInternal ( type , filter )","docstring":"/**\n * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs]\n *\n * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { .. }.`[colsOf][ColumnSet.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) }`\n *\n * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { .. }.`[colsOf][ColumnSet.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) { it: `[DataColumn][DataColumn]`<`[Int][Int]`> -> it.`[size][DataColumn.size]` > 10 } }`\n *\n * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs.FilterParam]\n * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs.Return]\n */"} {"signature":"public inline fun < reified C > ColumnSet < * > . colsOf ( noinline filter : ColumnFilter < C > = { true } , ) : TransformableColumnSet < C >","body":"= colsOf ( typeOf < C > ( ) , filter )","docstring":"/**\n * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs]\n *\n * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { .. }.`[colsOf][ColumnSet.colsOf]`<`[Int][Int]`>() }`\n *\n * `df.`[select][DataFrame.select]` { `[cols][ColumnsSelectionDsl.cols]` { .. }.`[colsOf][ColumnSet.colsOf]`<`[Int][Int]`> { it.`[size][DataColumn.size]` > 10 } }`\n *\n * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs.FilterParam]\n * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs.Return]\n */"} {"signature":"public fun < C > ColumnsSelectionDsl < * > . colsOf ( type : KType , filter : ColumnFilter < C > = { true } , ) : TransformableColumnSet < C >","body":"= asSingleColumn ( ) . colsOf ( type , filter )","docstring":"/**\n * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs]\n *\n * `df.`[select][DataFrame.select]` { `[colsOf][SingleColumn.colsOf]`(`[typeOf][typeOf]`<`[Int][Int]`>()) }`\n *\n * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs.FilterParam]\n * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs.Return]\n */"} {"signature":"public inline fun < reified C > ColumnsSelectionDsl < * > . colsOf ( noinline filter : ColumnFilter < C > = { true } , ) : TransformableColumnSet < C >","body":"= asSingleColumn ( ) . colsOf ( typeOf < C > ( ) , filter )","docstring":"/**\n * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs]\n *\n * `df.`[select][DataFrame.select]` { `[colsOf][SingleColumn.colsOf]`<`[Int][Int]`>() }`\n *\n * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs.FilterParam]\n * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs.Return]\n */"} {"signature":"public fun < C > SingleColumn < DataRow < * > > . colsOf ( type : KType , filter : ColumnFilter < C > = { true } , ) : TransformableColumnSet < C >","body":"= ensureIsColumnGroup ( ) . colsOfInternal ( type , filter )","docstring":"/**\n * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs]\n *\n * `df.`[select][DataFrame.select]` { myColumnGroup.`[colsOf][SingleColumn.colsOf]`<`[Int][Int]`>(`[typeOf][typeOf]`<`[Int][Int]`>()) { it: `[DataColumn][DataColumn]`<`[Int][Int]`> -> it.`[size][DataColumn.size]` > 10 } }`\n *\n * `df.`[select][DataFrame.select]` { myColumnGroup.`[colsOf][SingleColumn.colsOf]`<`[Int][Int]`>(`[typeOf][typeOf]`<`[Int][Int]`>()) }`\n *\n * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs.FilterParam]\n * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs.Return]\n */"} {"signature":"public inline fun < reified C > SingleColumn < DataRow < * > > . colsOf ( noinline filter : ColumnFilter < C > = { true } , ) : TransformableColumnSet < C >","body":"= colsOf ( typeOf < C > ( ) , filter )","docstring":"/**\n * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs]\n *\n * `df.`[select][DataFrame.select]` { myColumnGroup.`[colsOf][SingleColumn.colsOf]`<`[Int][Int]`> { it.`[size][DataColumn.size]` > 10 } }`\n *\n * `df.`[select][DataFrame.select]` { myColumnGroup.`[colsOf][SingleColumn.colsOf]`<`[Int][Int]`>() }`\n *\n * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs.FilterParam]\n * @include [ColsOfColumnsSelectionDsl.CommonColsOfDocs.Return]\n */"} {"signature":"@ Suppress ( \"\" ) internal fun < C > ColumnsResolver < * > . colsOfInternal ( type : KType , filter : ColumnFilter < C > , ) : TransformableColumnSet < C >","body":"= colsInternal { it . isSubtypeOf ( type ) && filter ( it . cast ( ) ) } as TransformableColumnSet < C >","docstring":"/**\n * If this [ColumnsResolver] is a [SingleColumn], it\n * returns a new [ColumnSet] containing the columns inside of this [SingleColumn] that\n * match the given [filter] and are the given [type].\n *\n * Else, it returns a new [ColumnSet] containing all columns in this [ColumnsResolver] that\n * match the given [filter] and are the given [type].\n */"} {"signature":"public fun run ( )","body":"public fun run ( )","docstring":"/**\n * @suppress\n */"} {"signature":"@ Suppress ( \"\" ) public expect inline fun Runnable ( crossinline block : ( ) -> Unit ) : Runnable","body":"@ Suppress ( \"\" ) public expect inline fun Runnable ( crossinline block : ( ) -> Unit ) : Runnable","docstring":"/**\n * Creates [Runnable] task instance.\n */"} {"signature":"internal fun interpretUnaryFunction ( name : String , type : String , a : Any ? ) : Any ?","body":"{ when ( name ) { \"\" -> when ( type ) { \"\" -> return ( a as Boolean ) . hashCode ( ) \"\" -> return ( a as Char ) . hashCode ( ) \"\" -> return ( a as Byte ) . hashCode ( ) \"\" -> return ( a as Short ) . hashCode ( ) \"\" -> return ( a as Int ) . hashCode ( ) \"\" -> return ( a as Float ) . hashCode ( ) \"\" -> return ( a as Long ) . hashCode ( ) \"\" -> return ( a as Double ) . hashCode ( ) \"\" -> return ( a as String ) . hashCode ( ) \"\" -> return ( a as Any ) . hashCode ( ) } \"\" -> when ( type ) { \"\" -> return ( a as Boolean ) . not ( ) } \"\" -> when ( type ) { \"\" -> return ( a as Boolean ) . toString ( ) \"\" -> return ( a as Char ) . toString ( ) \"\" -> return ( a as Byte ) . toString ( ) \"\" -> return ( a as Short ) . toString ( ) \"\" -> return ( a as Int ) . toString ( ) \"\" -> return ( a as Float ) . toString ( ) \"\" -> return ( a as Long ) . toString ( ) \"\" -> return ( a as Double ) . toString ( ) \"\" -> return ( a as String ) . toString ( ) \"\" -> return ( a as Any ) . toString ( ) \"\" -> return a ? . toString ( ) ? : \"\" \"\" -> return Unit . toString ( ) } \"\" -> when ( type ) { \"\" -> return ( a as Char ) . dec ( ) \"\" -> return ( a as Byte ) . dec ( ) \"\" -> return ( a as Short ) . dec ( ) \"\" -> return ( a as Int ) . dec ( ) \"\" -> return ( a as Float ) . dec ( ) \"\" -> return ( a as Long ) . dec ( ) \"\" -> return ( a as Double ) . dec ( ) } \"\" -> when ( type ) { \"\" -> return ( a as Char ) . inc ( ) \"\" -> return ( a as Byte ) . inc ( ) \"\" -> return ( a as Short ) . inc ( ) \"\" -> return ( a as Int ) . inc ( ) \"\" -> return ( a as Float ) . inc ( ) \"\" -> return ( a as Long ) . inc ( ) \"\" -> return ( a as Double ) . inc ( ) } \"\" -> when ( type ) { \"\" -> return ( a as Char ) . toByte ( ) \"\" -> return ( a as Byte ) . toByte ( ) \"\" -> return ( a as Short ) . toByte ( ) \"\" -> return ( a as Int ) . toByte ( ) \"\" -> return ( a as Float ) . toByte ( ) \"\" -> return ( a as Long ) . toByte ( ) \"\" -> return ( a as Double ) . toByte ( ) \"\" -> return ( a as Number ) . toByte ( ) } \"\" -> when ( type ) { \"\" -> return ( a as Char ) . toChar ( ) \"\" -> return ( a as Byte ) . toChar ( ) \"\" -> return ( a as Short ) . toChar ( ) \"\" -> return ( a as Int ) . toChar ( ) \"\" -> return ( a as Float ) . toChar ( ) \"\" -> return ( a as Long ) . toChar ( ) \"\" -> return ( a as Double ) . toChar ( ) \"\" -> return ( a as Number ) . toChar ( ) } \"\" -> when ( type ) { \"\" -> return ( a as Char ) . toDouble ( ) \"\" -> return ( a as Byte ) . toDouble ( ) \"\" -> return ( a as Short ) . toDouble ( ) \"\" -> return ( a as Int ) . toDouble ( ) \"\" -> return ( a as Float ) . toDouble ( ) \"\" -> return ( a as Long ) . toDouble ( ) \"\" -> return ( a as Double ) . toDouble ( ) \"\" -> return ( a as Number ) . toDouble ( ) } \"\" -> when ( type ) { \"\" -> return ( a as Char ) . toFloat ( ) \"\" -> return ( a as Byte ) . toFloat ( ) \"\" -> return ( a as Short ) . toFloat ( ) \"\" -> return ( a as Int ) . toFloat ( ) \"\" -> return ( a as Float ) . toFloat ( ) \"\" -> return ( a as Long ) . toFloat ( ) \"\" -> return ( a as Double ) . toFloat ( ) \"\" -> return ( a as Number ) . toFloat ( ) } \"\" -> when ( type ) { \"\" -> return ( a as Char ) . toInt ( ) \"\" -> return ( a as Byte ) . toInt ( ) \"\" -> return ( a as Short ) . toInt ( ) \"\" -> return ( a as Int ) . toInt ( ) \"\" -> return ( a as Float ) . toInt ( ) \"\" -> return ( a as Long ) . toInt ( ) \"\" -> return ( a as Double ) . toInt ( ) \"\" -> return ( a as Number ) . toInt ( ) } \"\" -> when ( type ) { \"\" -> return ( a as Char ) . toLong ( ) \"\" -> return ( a as Byte ) . toLong ( ) \"\" -> return ( a as Short ) . toLong ( ) \"\" -> return ( a as Int ) . toLong ( ) \"\" -> return ( a as Float ) . toLong ( ) \"\" -> return ( a as Long ) . toLong ( ) \"\" -> return ( a as Double ) . toLong ( ) \"\" -> return ( a as Number ) . toLong ( ) } \"\" -> when ( type ) { \"\" -> return ( a as Char ) . toShort ( ) \"\" -> return ( a as Byte ) . toShort ( ) \"\" -> return ( a as Short ) . toShort ( ) \"\" -> return ( a as Int ) . toShort ( ) \"\" -> return ( a as Float ) . toShort ( ) \"\" -> return ( a as Long ) . toShort ( ) \"\" -> return ( a as Double ) . toShort ( ) \"\" -> return ( a as Number ) . toShort ( ) } \"\" -> when ( type ) { \"\" -> return ( a as Byte ) . unaryMinus ( ) \"\" -> return ( a as Short ) . unaryMinus ( ) \"\" -> return ( a as Int ) . unaryMinus ( ) \"\" -> return ( a as Float ) . unaryMinus ( ) \"\" -> return ( a as Long ) . unaryMinus ( ) \"\" -> return ( a as Double ) . unaryMinus ( ) } \"\" -> when ( type ) { \"\" -> return ( a as Byte ) . unaryPlus ( ) \"\" -> return ( a as Short ) . unaryPlus ( ) \"\" -> return ( a as Int ) . unaryPlus ( ) \"\" -> return ( a as Float ) . unaryPlus ( ) \"\" -> return ( a as Long ) . unaryPlus ( ) \"\" -> return ( a as Double ) . unaryPlus ( ) } \"\" -> when ( type ) { \"\" -> return ( a as Int ) . inv ( ) \"\" -> return ( a as Long ) . inv ( ) } \"\" -> when ( type ) { \"\" -> return ( a as String ) . length \"\" -> return ( a as CharSequence ) . length } \"\" -> when ( type ) { \"\" -> return ( a as Throwable ) . cause } \"\" -> when ( type ) { \"\" -> return ( a as Throwable ) . message } \"\" -> when ( type ) { \"\" -> return ( a as BooleanArray ) . size \"\" -> return ( a as CharArray ) . size \"\" -> return ( a as ByteArray ) . size \"\" -> return ( a as ShortArray ) . size \"\" -> return ( a as IntArray ) . size \"\" -> return ( a as FloatArray ) . size \"\" -> return ( a as LongArray ) . size \"\" -> return ( a as DoubleArray ) . size \"\" -> return ( a as Array < Any ? > ) . size } \"\" -> when ( type ) { \"\" -> return ( a as BooleanArray ) . iterator ( ) \"\" -> return ( a as CharArray ) . iterator ( ) \"\" -> return ( a as ByteArray ) . iterator ( ) \"\" -> return ( a as ShortArray ) . iterator ( ) \"\" -> return ( a as IntArray ) . iterator ( ) \"\" -> return ( a as FloatArray ) . iterator ( ) \"\" -> return ( a as LongArray ) . iterator ( ) \"\" -> return ( a as DoubleArray ) . iterator ( ) \"\" -> return ( a as Array < Any ? > ) . iterator ( ) } \"\" -> when ( type ) { \"\" -> return a ! ! } \"\" -> when ( type ) { \"\" -> return ( a as Char ) . code } } throw InterpreterMethodNotFoundError ( \"\" ) }","docstring":"/** This file is generated by `./gradlew generateInterpreterMap`. DO NOT MODIFY MANUALLY */"} {"signature":"fun < T1 > Tuple1 < T1 > . splitAt0 ( ) : Tuple2 < EmptyTuple , Tuple1 < T1 > >","body":"= Tuple2 < EmptyTuple , Tuple1 < T1 > > ( EmptyTuple , Tuple1 < T1 > ( this . _1 ( ) ) )","docstring":"/**\n * Given a tuple `t(a1, ..., am)`, returns a [Tuple2] of the tuple `t(a1, ..., an)`\n * consisting of the first n elements, and the tuple `t(an+1, ..., am)` consisting\n * of the remaining elements.\n * Splitting at 0 or at n results in `t(t(), myTuple)` or `t(myTuple, t())` respectively.\n *\n * For example:\n * ```kotlin\n * t(1, 2, 3, 4, 5).splitAt2() == t(t(1, 2), t(3, 4, 5))\n * ```\n */"} {"signature":"public operator fun String . rangeTo ( endInclusive : String ) : ColumnSet < * >","body":"= toColumnAccessor ( ) . rangeTo ( endInclusive . toColumnAccessor ( ) )","docstring":"/**\n * @include [CommonRangeOfColumnsDocs]\n * {@set [CommonRangeOfColumnsDocs.Example] `\"fromColumn\"`[`..`][String.rangeTo]`\"toColumn\"`}\n */"} {"signature":"public operator fun String . rangeTo ( endInclusive : KProperty < * > ) : ColumnSet < * >","body":"= toColumnAccessor ( ) . rangeTo ( endInclusive . toColumnAccessor ( ) )","docstring":"/**\n * @include [CommonRangeOfColumnsDocs]\n * {@set [CommonRangeOfColumnsDocs.Example] `\"fromColumn\"`[`..`][String.rangeTo]`Type::toColumn`}\n */"} {"signature":"public operator fun String . rangeTo ( endInclusive : AnyColumnReference ) : ColumnSet < * >","body":"= toColumnAccessor ( ) . rangeTo ( endInclusive )","docstring":"/**\n * @include [CommonRangeOfColumnsDocs]\n * {@set [CommonRangeOfColumnsDocs.Example] `\"fromColumn\"`[`..`][String.rangeTo]`toColumn`}\n */"} {"signature":"public operator fun KProperty < * > . rangeTo ( endInclusive : String ) : ColumnSet < * >","body":"= toColumnAccessor ( ) . rangeTo ( endInclusive . toColumnAccessor ( ) )","docstring":"/**\n * @include [CommonRangeOfColumnsDocs]\n * {@set [CommonRangeOfColumnsDocs.Example] `Type::fromColumn`[`..`][KProperty.rangeTo]`\"toColumn\"`}\n */"} {"signature":"public operator fun KProperty < * > . rangeTo ( endInclusive : KProperty < * > ) : ColumnSet < * >","body":"= toColumnAccessor ( ) . rangeTo ( endInclusive . toColumnAccessor ( ) )","docstring":"/**\n * @include [CommonRangeOfColumnsDocs]\n * {@set [CommonRangeOfColumnsDocs.Example] `Type::fromColumn`[`..`][KProperty.rangeTo]`Type::toColumn`}\n */"} {"signature":"public operator fun KProperty < * > . rangeTo ( endInclusive : AnyColumnReference ) : ColumnSet < * >","body":"= toColumnAccessor ( ) . rangeTo ( endInclusive )","docstring":"/**\n * @include [CommonRangeOfColumnsDocs]\n * {@set [CommonRangeOfColumnsDocs.Example] `Type::fromColumn`[`..`][KProperty.rangeTo]`toColumn`}\n */"} {"signature":"public operator fun AnyColumnReference . rangeTo ( endInclusive : String ) : ColumnSet < * >","body":"= rangeTo ( endInclusive . toColumnAccessor ( ) )","docstring":"/**\n * @include [CommonRangeOfColumnsDocs]\n * {@set [CommonRangeOfColumnsDocs.Example] `fromColumn`[`..`][ColumnReference.rangeTo]`\"toColumn\"`}\n */"} {"signature":"public operator fun AnyColumnReference . rangeTo ( endInclusive : KProperty < * > ) : ColumnSet < * >","body":"= rangeTo ( endInclusive . toColumnAccessor ( ) )","docstring":"/**\n * @include [CommonRangeOfColumnsDocs]\n * {@set [CommonRangeOfColumnsDocs.Example] `fromColumn`[`..`][ColumnReference.rangeTo]`Type::toColumn`}\n */"} {"signature":"public operator fun AnyColumnReference . rangeTo ( endInclusive : AnyColumnReference ) : ColumnSet < * >","body":"= createColumnSet { context -> val startPath = this@rangeTo . resolveSingle ( context ) ! ! . path val endPath = endInclusive . resolveSingle ( context ) ! ! . path val parentPath = startPath . parent ( ) val parentEndPath = endPath . parent ( ) require ( parentPath == parentEndPath ) { \"\" } val parentCol = context . df . getColumnGroup ( parentPath ! ! ) val startIndex = parentCol . getColumnIndex ( startPath . name ) val endIndex = parentCol . getColumnIndex ( endPath . name ) require ( startIndex <= endIndex ) { \"\" } ( startIndex .. endIndex ) . map { parentCol . getColumn ( it ) . let { it . addPath ( parentPath + it . name ) } } }","docstring":"/**\n * @include [CommonRangeOfColumnsDocs]\n * {@set [CommonRangeOfColumnsDocs.Example] `fromColumn`[`..`][ColumnReference.rangeTo]`toColumn`}\n */"} {"signature":"fun attribute ( key : String , value : String )","body":"{ attrs [ key ] = value }","docstring":"/**\n * Appends an attribute to the generated podspec\n */"} {"signature":"fun rawStatement ( statement : String )","body":"{ statements . add ( statement ) }","docstring":"/**\n * Appends a statement 'as is' to the end of the generated podspec\n */"} {"signature":"@ Suppress ( \"\" ) inline fun < reified T : NativePointed > interpretNullablePointed ( ptr : NativePtr ) : T ?","body":"{ if ( ptr == nativeNullPtr ) { return null } else { val result = nativeMemUtils . allocateInstance < T > ( ) result . rawPtr = ptr return result } }","docstring":"/**\n * Returns interpretation of entity with given pointer, or `null` if it is null.\n *\n * @param T must not be abstract\n */"} {"signature":"fun < T : CPointed > interpretCPointer ( rawValue : NativePtr )","body":"= if ( rawValue == nativeNullPtr ) { null } else { CPointer < T > ( rawValue ) }","docstring":"/**\n * Creates a [CPointer] from the raw pointer of [NativePtr].\n *\n * @return a [CPointer] representation, or `null` if the [rawValue] represents native `nullptr`.\n */"} {"signature":"fun ConeClassifierLookupTag . toSymbol ( useSiteSession : FirSession ) : FirClassifierSymbol < * > ?","body":"= when ( this ) { is ConeClassLikeLookupTag -> toSymbol ( useSiteSession ) is ConeClassifierLookupTagWithFixedSymbol -> this . symbol else -> error ( \"\" ) }","docstring":"/**\n * Main operation on the [ConeClassifierLookupTag]\n *\n * Lookups the tag into its target within the given [useSiteSession]\n *\n * The second step of type refinement, see `/docs/fir/k2_kmp.md`\n *\n * @see ConeClassifierLookupTag\n */"} {"signature":"@ OptIn ( LookupTagInternals :: class ) fun ConeClassLikeLookupTag . toSymbol ( useSiteSession : FirSession ) : FirClassLikeSymbol < * > ?","body":"{ if ( this is ConeClassLookupTagWithFixedSymbol ) { return this . symbol } ( this as? ConeClassLikeLookupTagImpl ) ? . boundSymbol ? . takeIf { it . first === useSiteSession } ? . let { return it . second } return useSiteSession . symbolProvider . getClassLikeSymbolByClassId ( classId ) . also { ( this as? ConeClassLikeLookupTagImpl ) ? . bindSymbolToLookupTag ( useSiteSession , it ) } }","docstring":"/**\n * @see toSymbol\n */"} {"signature":"fun ConeClassLikeLookupTag . toClassSymbol ( session : FirSession ) : FirClassSymbol < * > ?","body":"= toSymbol ( session ) as? FirClassSymbol < * >","docstring":"/**\n * @see toSymbol\n */"} {"signature":"fun ConeClassLikeLookupTag . toFirRegularClassSymbol ( session : FirSession ) : FirRegularClassSymbol ?","body":"= toSymbol ( session ) as? FirRegularClassSymbol","docstring":"/**\n * @see toSymbol\n */"} {"signature":"public fun detectPoses ( image : I , confidence : Float = ) : MultiPoseDetectionResult","body":"{ val result = predict ( image ) val filteredPoses = result . poses . filter { ( detectedObject , _ ) -> detectedObject . probability > confidence } return MultiPoseDetectionResult ( filteredPoses ) }","docstring":"/**\n * Detects poses for the given [image] with the given [confidence].\n * @param [confidence] confidence value to use\n */"} {"signature":"@ InternalCoroutinesApi public fun MainDispatcherFactory . tryCreateDispatcher ( factories : List < MainDispatcherFactory > ) : MainCoroutineDispatcher","body":"= try { createDispatcher ( factories ) } catch ( cause : Throwable ) { createMissingDispatcher ( cause , hintOnError ( ) ) }","docstring":"/**\n * If anything goes wrong while trying to create main dispatcher (class not found,\n * initialization failed, etc), then replace the main dispatcher with a special\n * stub that throws an error message on any attempt to actually use it.\n *\n * @suppress internal API\n */"} {"signature":"@ InternalCoroutinesApi public fun MainCoroutineDispatcher . isMissing ( ) : Boolean","body":"= this . immediate is MissingMainCoroutineDispatcher","docstring":"/** @suppress */"} {"signature":"@ ExternalKotlinTargetApi fun < T : DecoratedExternalKotlinTarget > ExternalKotlinTargetDescriptor ( configure : ExternalKotlinTargetDescriptorBuilder < T > . ( ) -> Unit , ) : ExternalKotlinTargetDescriptor < T >","body":"{ return ExternalKotlinTargetDescriptorBuilder < T > ( ) . also ( configure ) . build ( ) }","docstring":"/**\n * Creates a new [ExternalKotlinTargetDescriptor] using the builder pattern.\n * There are some required properties that have to be set.\n * Check [ExternalKotlinTargetDescriptorBuilder] for further details.\n *\n * * The following properties have to be specified:\n * * - [ExternalKotlinTargetDescriptorBuilder.targetName]\n * * - [ExternalKotlinTargetDescriptorBuilder.platformType]\n * * - [ExternalKotlinTargetDescriptorBuilder.targetFactory]\n *\n * Not providing a required/necessary property will throw [IllegalStateException]\n */"} {"signature":"fun configure ( action : ( T ) -> Unit )","body":"{ val configure = this . configure if ( configure == null ) this . configure = action else this . configure = { configure ( it ) ; action ( it ) } }","docstring":"/**\n * Generic configuration that will be invoked when building the target.\n * This configuration is called right after creating the instance and before\n * publishing the target to all subscribers of `kotlin.targets.all {}`\n */"} {"signature":"fun configureIdeImport ( action : IdeMultiplatformImport . ( ) -> Unit )","body":"{ val configureIdeImport = this . configureIdeImport if ( configureIdeImport == null ) this . configureIdeImport = action else this . configureIdeImport = { configureIdeImport ( ) ; action ( ) } }","docstring":"/**\n * Main entrance of configuring the ide import:\n * The [IdeMultiplatformImport] instance passed to this function shall\n * not be captured and used outside of this block.\n *\n * The [IdeMultiplatformImport] instance shall not be retrieved any other way than using this function.\n */"} {"signature":"fun create ( prefix : String , suffix : String = \"\" ) : File","body":"= File ( dir , \"\" )","docstring":"/**\n * Create file named {name}{suffix} inside temporary dir\n */"} {"signature":"fun processClassifiersByNameWithSubstitutionFromBothLevelsConditionally ( name : Name , processor : ( FirClassifierSymbol < * > , ConeSubstitutor ) -> Boolean , )","body":"{ var wasFoundAny = false first . processClassifiersByNameWithSubstitution ( name ) { symbol , substitutor -> wasFoundAny = processor ( symbol , substitutor ) } if ( ! wasFoundAny ) { second . processClassifiersByNameWithSubstitution ( name , processor :: invoke ) } }","docstring":"/**\n * Starts by querying [first] and calling [processor] with the results.\n * If [processor] doesn't return `true` for any of them (or no symbols were found), also queries [second] and calls [processor].\n */"} {"signature":"@ InternalDokkaApi fun AbstractDokkaTask . buildJsonConfiguration ( prettyPrint : Boolean = true ) : String","body":"{ val configuration = this . buildDokkaConfiguration ( ) return if ( prettyPrint ) { configuration . toPrettyJsonString ( ) } else { configuration . toCompactJsonString ( ) } }","docstring":"/**\n * Serializes [DokkaConfiguration] of this [AbstractDokkaTask] as json\n *\n * Should be used for short-term debugging only, no guarantees are given for the support of this API.\n *\n * Better alternative should be introduced as part of [#2873](https://github.com/Kotlin/dokka/issues/2873).\n */"} {"signature":"internal fun loadSequentialModelConfiguration ( configuration : File , inputShape : IntArray ? = null ) : Sequential","body":"{ val sequentialConfig = loadSerializedModel ( configuration ) return deserializeSequentialModel ( sequentialConfig , inputShape ) }","docstring":"/**\n * Loads a [Sequential] model from json file with model configuration.\n *\n * @param [configuration] File containing model configuration.\n * @return Non-compiled and non-trained Sequential model.\n */"} {"signature":"internal fun loadSequentialModelLayers ( config : KerasModel ? , inputShape : IntArray ? = null ) : Pair < Input , List < Layer > >","body":"{ val kerasLayers = config ! ! . config ! ! . layers ! ! val input = createInputLayer ( kerasLayers . first ( ) , inputShape ) val layers = kerasLayers . filter { ! it . class_name . equals ( LAYER_INPUT ) } . mapTo ( mutableListOf ( ) ) { convertToLayer ( it ) } return Pair ( input , layers ) }","docstring":"/**\n * Loads a [Sequential] model layers from json file with model configuration.\n *\n * NOTE: This method is useful in transfer learning, when you need to manipulate on layers before building the Sequential model.\n *\n * @param config Model configuration.\n * @return Pair of .\n */"} {"signature":"internal fun loadFunctionalModelConfiguration ( configuration : File , inputShape : IntArray ? = null ) : Functional","body":"{ val functionalConfig = loadSerializedModel ( configuration ) return deserializeFunctionalModel ( functionalConfig , inputShape ) }","docstring":"/**\n * Loads a [Sequential] model from json file with model configuration.\n *\n * @param [configuration] File containing model configuration.\n * @return Non-compiled and non-trained Sequential model.\n */"} {"signature":"internal fun loadFunctionalModelLayers ( config : KerasModel ? , inputShape : IntArray ? = null ) : List < Layer >","body":"{ val layers = mutableListOf < Layer > ( ) val layersByNames = mutableMapOf < String , Layer > ( ) val kerasLayers = config ! ! . config ! ! . layers ! ! val input = createInputLayer ( kerasLayers . first ( ) , inputShape ) layers . add ( input ) layersByNames [ input . name ] = input kerasLayers . forEach { if ( ! it . class_name . equals ( LAYER_INPUT ) ) { val layer = convertToLayer ( it , layersByNames ) layers . add ( layer ) layersByNames [ layer . name ] = layer } } return layers }","docstring":"/**\n * Loads a [Functional] model layers from json file with model configuration.\n *\n * NOTE: This method is useful in transfer learning, when you need to manipulate on layers before building the Functional model.\n *\n * @param config Model configuration.\n * @return Pair of .\n */"} {"signature":"private fun createInputLayer ( layer : KerasLayer , inputShape : IntArray ? = null ) : Input","body":"{ val inputLayerDims = if ( inputShape != null ) { inputShape . map { it . toLong ( ) } . toLongArray ( ) } else { val batchInputShape = layer . config ! ! . batch_input_shape ! ! batchInputShape . subList ( , batchInputShape . size ) . map { it ! ! . toLong ( ) } . toLongArray ( ) } val inputLayerName = if ( layer . class_name . equals ( LAYER_INPUT ) ) layer . config ! ! . name ? : \"\" else \"\" return Input ( * inputLayerDims , name = inputLayerName ) }","docstring":"/**\n * The layer creator functions should be put below.\n */"} {"signature":"protected fun incrementInductionVariable ( builder : DeclarationIrBuilder ) : IrStatement","body":"= with ( builder ) { with ( headerInfo . progressionType ) { val stepType = stepClass . defaultType val plusFun = elementClass . defaultType . getClass ( ) ! ! . functions . single { it . name == OperatorNameConventions . PLUS && it . valueParameters . size == && it . valueParameters [ ] . type == stepType } irSet ( inductionVariable . symbol , irCallOp ( plusFun . symbol , plusFun . returnType , irGet ( inductionVariable ) , stepExpression . shallowCopy ( ) , IrStatementOrigin . PLUSEQ ) , IrStatementOrigin . PLUSEQ ) } }","docstring":"/** Statement used to increment the induction variable. */"} {"signature":"override fun < T > injectCoroutineContext ( publisher : Publisher < T > , coroutineContext : CoroutineContext ) : Publisher < T >","body":"{ val reactorContext = coroutineContext [ ReactorContext ] ? . context ? : return publisher return when ( publisher ) { is Mono -> publisher . contextWrite ( reactorContext ) is Flux -> publisher . contextWrite ( reactorContext ) else -> publisher } }","docstring":"/**\n * Injects all values from the [ReactorContext] entry of the given coroutine context\n * into the downstream [Context] of Reactor's [Publisher] instances of [Mono] or [Flux].\n */"} {"signature":"public abstract fun forward ( tf : Ops , input : Operand < Float > ) : Operand < Float >","body":"public abstract fun forward ( tf : Ops , input : Operand < Float > ) : Operand < Float >","docstring":"/**\n * Applies the activation functions to the [input] to produce the output.\n *\n * @param [tf] TensorFlow graph API for building operations.\n * @param [input] TensorFlow graph leaf node representing layer output before activation function.\n */"} {"signature":"fun isAllowed ( qualifiedName : String ) : Boolean","body":"fun isAllowed ( qualifiedName : String ) : Boolean","docstring":"/**\n * @return **true** if an annotations with [qualifiedName] is allowed\n */"} {"signature":"fun filtered ( annotations : Collection < PsiAnnotation > ) : Collection < PsiAnnotation >","body":"fun filtered ( annotations : Collection < PsiAnnotation > ) : Collection < PsiAnnotation >","docstring":"/**\n * @return a filtered collection where each annotation in a list has an allowed qualifier\n */"} {"signature":"public expect inline fun < reified T > Array < out T > ? . orEmpty ( ) : Array < out T >","body":"public expect inline fun < reified T > Array < out T > ? . orEmpty ( ) : Array < out T >","docstring":"/**\n * Returns the array if it's not `null`, or an empty array otherwise.\n * @sample samples.collections.Arrays.Usage.arrayOrEmpty\n */"} {"signature":"public expect inline fun < reified T > Collection < T > . toTypedArray ( ) : Array < T >","body":"public expect inline fun < reified T > Collection < T > . toTypedArray ( ) : Array < T >","docstring":"/**\n * Returns a *typed* array containing all the elements of this collection.\n *\n * Allocates an array of runtime type `T` having its size equal to the size of this collection\n * and populates the array with the elements of this collection.\n * @sample samples.collections.Collections.Collections.collectionToTypedArray\n */"} {"signature":"@ SinceKotlin ( \"\" ) public expect fun < T > MutableList < T > . fill ( value : T ) : Unit","body":"@ SinceKotlin ( \"\" ) public expect fun < T > MutableList < T > . fill ( value : T ) : Unit","docstring":"/**\n * Fills the list with the provided [value].\n *\n * Each element in the list gets replaced with the [value].\n */"} {"signature":"@ SinceKotlin ( \"\" ) public expect fun < T > MutableList < T > . shuffle ( ) : Unit","body":"@ SinceKotlin ( \"\" ) public expect fun < T > MutableList < T > . shuffle ( ) : Unit","docstring":"/**\n * Randomly shuffles elements in this list.\n *\n * See: https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle#The_modern_algorithm\n */"} {"signature":"@ SinceKotlin ( \"\" ) public expect fun < T > Iterable < T > . shuffled ( ) : List < T >","body":"@ SinceKotlin ( \"\" ) public expect fun < T > Iterable < T > . shuffled ( ) : List < T >","docstring":"/**\n * Returns a new list with the elements of this collection randomly shuffled.\n */"} {"signature":"public expect fun < T : Comparable < T > > MutableList < T > . sort ( ) : Unit","body":"public expect fun < T : Comparable < T > > MutableList < T > . sort ( ) : Unit","docstring":"/**\n * Sorts elements in the list in-place according to their natural sort order.\n *\n * The sort is _stable_. It means that equal elements preserve their order relative to each other after sorting.\n *\n * @sample samples.collections.Collections.Sorting.sortMutableList\n */"} {"signature":"public expect fun < T > MutableList < T > . sortWith ( comparator : Comparator < in T > ) : Unit","body":"public expect fun < T > MutableList < T > . sortWith ( comparator : Comparator < in T > ) : Unit","docstring":"/**\n * Sorts elements in the list in-place according to the order specified with [comparator].\n *\n * The sort is _stable_. It means that equal elements preserve their order relative to each other after sorting.\n *\n * @sample samples.collections.Collections.Sorting.sortMutableListWith\n */"} {"signature":"fun filtersPlot ( conv2DLayer : Conv2D , plotFeature : PlotFeature = PlotFeature . GRAY , imageSize : Int = , columns : Int = ) : Figure","body":"{ @ Suppress ( \"\" ) val weights = conv2DLayer . weights . values . toTypedArray ( ) [ ] as TensorImageData val xyInOut = extractXYInputOutputAxeSizes ( weights , FILTER_LAYERS_PERMUTATION ) val plots = cartesianProductIndices ( xyInOut [ ] , xyInOut [ ] ) . map { ( i , o ) -> xyPlot ( xyInOut [ ] , xyInOut [ ] , plotFeature ) { x , y -> weights [ y ] [ x ] [ i ] [ o ] } } return columnPlot ( plots , columns , imageSize ) }","docstring":"/**\n * Create a column plot of tile plots for weights of Conv2D layer filters.\n *\n * @param conv2DLayer which weights will be changed to tile plot\n * @param plotFeature filling colors of the created plot\n * @param imageSize size of width and height of single plot in px\n * @param columns number of columns in which the single filters plots are arranged\n * @return a figure representing the weights plots\n */"} {"signature":"fun modelActivationOnLayersPlot ( model : TrainableModel , x : FloatData , plotFeature : PlotFeature = PlotFeature . GRAY , imageSize : Int = , columns : Int = , ) : List < Figure >","body":"{ val activations = model . predictAndGetActivations ( x ) . second @ Suppress ( \"\" ) val activationArrays = activations . mapNotNull { it as? TensorImageData } return activationArrays . map { weights -> val xyInOut = extractXYInputOutputAxeSizes ( weights , ACTIVATION_LAYERS_PERMUTATION ) val plots = cartesianProductIndices ( xyInOut [ ] , xyInOut [ ] ) . map { ( i , o ) -> xyPlot ( xyInOut [ ] , xyInOut [ ] , plotFeature ) { x , y -> weights [ i ] [ y ] [ x ] [ o ] } } columnPlot ( plots , columns , imageSize ) } }","docstring":"/**\n * Create a list of columns plots for model activation on layers.\n * The model is evaluated on given input and the obtained activations arrays\n * of the following layers are converted into separated figures with columns\n * plots of the weights for the filters in [Conv2D] layers\n *\n * @param model that is evaluated to get the activations on its weights\n * @param x input for model evaluation\n * @param plotFeature filling colors of the created plot\n * @param imageSize size of width and height of single plot in px\n * @param columns number of columns in which the single filters plots are arranged\n * @return list of figures representing the activations plots for model evaluation\n */"} {"signature":"@ Test fun testMainIsJavaFx ( )","body":"{ assertSame ( Dispatchers . Swing , Dispatchers . Main ) }","docstring":"/** Tests that the Main dispatcher is in fact the JavaFx one. */"} {"signature":"@ Suppress ( \"\" ) fun FirDeclarationCollector < FirBasedSymbol < * > > . collectTopLevel ( file : FirFile , packageMemberScope : FirPackageMemberScope )","body":"{ for ( ( declarationName , group ) in groupTopLevelByName ( file . declarations , context ) ) { val groupHasClassLikesOrProperties = group . classLikes . isNotEmpty ( ) || group . properties . isNotEmpty ( ) val groupHasSimpleFunctions = group . simpleFunctions . isNotEmpty ( ) fun collect ( declarations : List < Pair < FirBasedSymbol < * > , String > > , conflictingSymbol : FirBasedSymbol < * > , conflictingPresentation : String ? = null , conflictingFile : FirFile ? = null , ) { for ( ( declaration , declarationPresentation ) in declarations ) { collectTopLevelConflict ( declaration , declarationPresentation , file , conflictingSymbol , conflictingPresentation , conflictingFile ) session . lookupTracker ? . recordNameLookup ( declarationName , file . packageFqName . asString ( ) , declaration . source , file . source ) } } fun collectFromClassifierSource ( conflictingSymbol : FirClassifierSymbol < * > , conflictingPresentation : String ? = null , conflictingFile : FirFile ? = null , ) { collect ( group . classLikes , conflictingSymbol , conflictingPresentation , conflictingFile ) collect ( group . properties , conflictingSymbol , conflictingPresentation , conflictingFile ) if ( groupHasSimpleFunctions ) { if ( conflictingSymbol !is FirClassLikeSymbol < * > ) { return } conflictingSymbol . expandedClassWithConstructorsScope ( context ) ? . let { ( expandedClass , scopeWithConstructors ) -> if ( expandedClass . classKind == ClassKind . OBJECT || expandedClass . classKind == ClassKind . ENUM_ENTRY ) { return } scopeWithConstructors . processDeclaredConstructors { constructor -> val ctorRepresentation = FirRedeclarationPresenter . represent ( constructor , conflictingSymbol ) collect ( group . simpleFunctions , conflictingSymbol = constructor , conflictingPresentation = ctorRepresentation ) } } } } if ( groupHasSimpleFunctions || group . constructors . isNotEmpty ( ) ) { packageMemberScope . processFunctionsByName ( declarationName ) { collect ( group . simpleFunctions , it ) collect ( group . constructors , it ) } } if ( groupHasClassLikesOrProperties || groupHasSimpleFunctions ) { packageMemberScope . processClassifiersByNameWithSubstitution ( declarationName ) { symbol , _ -> collectFromClassifierSource ( conflictingSymbol = symbol ) } session . nameConflictsTracker ? . let { it as? FirNameConflictsTracker } ? . redeclaredClassifiers ? . get ( ClassId ( file . packageFqName , declarationName ) ) ? . forEach { collectFromClassifierSource ( conflictingSymbol = it . classifier , conflictingFile = it . file ) } for ( ( classLike , representation ) in group . classLikes ) { collectFromClassifierSource ( classLike , conflictingPresentation = representation , conflictingFile = file ) } } if ( groupHasClassLikesOrProperties || group . extensionProperties . isNotEmpty ( ) ) { packageMemberScope . processPropertiesByName ( declarationName ) { collect ( group . classLikes , conflictingSymbol = it ) collect ( group . properties , conflictingSymbol = it ) collect ( group . extensionProperties , conflictingSymbol = it ) } } } }","docstring":"/**\n * To check top-level declarations for redeclarations, we check multiple sources (the packageMemberScope's properties, functions\n * and classifiers), redeclared classifiers from session.nameConflictsTracker and the file's declarations themselves.\n * To prevent inspecting the same source multiple times, we group the declarations in the file by name and subdivide them into\n * buckets (the properties of DeclarationGroup).\n *\n * Depending on the presence of declarations in the buckets, some checks can be omitted.\n * E.g., if there are no functions and no classes with constructors in the file, we don't need to inspect functions.\n *\n * #### Matrix of possible conflicts between \"sources\" and \"buckets\"\n *\n * | | simpleFunctions | constructors | classLikes | Properties | extensionProperties |\n * |-------------------------|-----------------|--------------|------------|------------|---------------------|\n * | functions | X | X | | | |\n * | classifiers | | | X | X | |\n * | constructors of classes | X | | | | |\n * | properties | | | X | X | X |\n */"} {"signature":"fun checkForLocalRedeclarations ( elements : List < FirElement > , context : CheckerContext , reporter : DiagnosticReporter )","body":"{ if ( elements . size <= ) return val multimap = ListMultimap < Name , FirBasedSymbol < * > > ( ) for ( element in elements ) { val name : Name ? val symbol : FirBasedSymbol < * > ? when ( element ) { is FirVariable -> { symbol = element . symbol name = element . name } is FirOuterClassTypeParameterRef -> { continue } is FirTypeParameterRef -> { symbol = element . symbol name = symbol . name } else -> { symbol = null name = null } } if ( name ? . isSpecial == false ) { multimap . put ( name , symbol ! ! ) } } for ( key in multimap . keys ) { val conflictingElements = multimap [ key ] if ( conflictingElements . size > ) { for ( conflictingElement in conflictingElements ) { reporter . reportOn ( conflictingElement . source , FirErrors . REDECLARATION , conflictingElements , context ) } } } }","docstring":"/** Checks for redeclarations of value and type parameters, and local variables. */"} {"signature":"private fun resolveJvmSourceSets ( sourceSet : KotlinSourceSet ) : Iterable < IdeaKotlinDependency >","body":"{ return IdeBinaryDependencyResolver ( binaryType = IdeaKotlinBinaryDependency . KOTLIN_COMPILE_BINARY_TYPE , artifactResolutionStrategy = IdeBinaryDependencyResolver . ArtifactResolutionStrategy . PlatformLikeSourceSet ( setupPlatformResolutionAttributes = { sourceSet . internal . compilations . filter { it . platformType == KotlinPlatformType . jvm } . map { compilation -> compilation . internal . configurations . compileDependencyConfiguration . attributes } . map { attributes -> attributes . toMap ( ) . toList ( ) . toSet ( ) } . reduceOrNull { acc , next -> acc intersect next } . orEmpty ( ) . forEach { ( key , value ) -> @ Suppress ( \"\" ) setAttributeProvider ( sourceSet . project , key as Attribute < Any > ) { value as Any } } } , componentFilter = { id -> id is ProjectComponentIdentifier } ) ) . resolve ( sourceSet ) }","docstring":"/**\n * Pretend that this [sourceSet] is 'jvm' and resolve binaries.\n * #### Setting up attributes:\n * In order to set up the 'platform like' / 'jvm like' dependency resolution, this algorithm\n * will look at all 'jvm' based compilations, uses their 'compileDependencyConfiguration' as reference and\n * then uses the intersection of all available attributes\n *\n * #### componentFilter:\n * This resolver will just care about resolving project dependencies.\n * Therefore, a componentFilter is added to only resolve project dependencies.\n * We expect to resolve project artifact dependencies which can then be matched to the corresponding\n * SourceSets on IDE side.\n */"} {"signature":"public fun < I , O > Operation < I , O > . onResult ( block : ( O ) -> Unit ) : Operation < I , O >","body":"{ return PreprocessingPipeline ( this , object : Operation < O , O > { override fun apply ( input : O ) : O { block ( input ) return input } override fun getOutputShape ( inputShape : TensorShape ) : TensorShape = inputShape } ) }","docstring":"/**\n * Convenience functions for executing custom logic after applying [Operation].\n * Could be useful for debugging purposes.\n */"} {"signature":"public fun < I , M , O > Operation < I , M > . call ( operation : Operation < M , O > ) : Operation < I , O >","body":"{ return PreprocessingPipeline ( this , operation ) }","docstring":"/**\n * Applies provided [operation] to the preprocessing pipeline.\n */"} {"signature":"internal actual fun String . nativeIndexOf ( ch : Char , fromIndex : Int ) : Int","body":"{ for ( index in fromIndex . coerceAtLeast ( ) .. this . lastIndex ) { if ( ch == get ( index ) ) return index } return - }","docstring":"/**\n * Returns the index within this string of the first occurrence of the specified character, starting from the specified offset.\n */"} {"signature":"internal actual fun String . nativeLastIndexOf ( ch : Char , fromIndex : Int ) : Int","body":"{ for ( index in fromIndex . coerceAtMost ( this . lastIndex ) downTo ) { if ( ch == get ( index ) ) return index } return - }","docstring":"/**\n * Returns the index within this string of the last occurrence of the specified character.\n */"} {"signature":"internal actual fun String . nativeIndexOf ( str : String , fromIndex : Int ) : Int","body":"{ for ( index in fromIndex . coerceAtLeast ( ) .. ( this . length - str . length ) ) { if ( str . regionMatchesImpl ( , this , index , str . length , false ) ) { return index } } return - }","docstring":"/**\n * Returns the index within this string of the first occurrence of the specified substring, starting from the specified offset.\n */"} {"signature":"internal actual fun String . nativeLastIndexOf ( str : String , fromIndex : Int ) : Int","body":"{ for ( index in fromIndex . coerceAtMost ( this . length - str . length ) downTo ) { if ( str . regionMatchesImpl ( , this , index , str . length , false ) ) { return index } } return - }","docstring":"/**\n * Returns the index within this string of the last occurrence of the specified character, starting from the specified offset.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Deprecated ( \"\" , ReplaceWith ( \"\" ) ) @ DeprecatedSinceKotlin ( warningSince = \"\" , errorSince = \"\" ) public actual fun String ( chars : CharArray ) : String","body":"= chars . concatToString ( )","docstring":"/**\n * Converts the characters in the specified array to a string.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Deprecated ( \"\" , ReplaceWith ( \"\" ) ) @ DeprecatedSinceKotlin ( warningSince = \"\" , errorSince = \"\" ) public actual fun String ( chars : CharArray , offset : Int , length : Int ) : String","body":"{ if ( offset < || length < || offset + length > chars . size ) throw IndexOutOfBoundsException ( ) val copy = WasmCharArray ( length ) copyWasmArray ( chars . storage , copy , offset , , length ) return copy . createString ( ) }","docstring":"/**\n * Converts the characters from a portion of the specified array to a string.\n *\n * @throws IndexOutOfBoundsException if either [offset] or [length] are less than zero\n * or `offset + length` is out of [chars] array bounds.\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual fun CharArray . concatToString ( ) : String","body":"{ val thisStorage = this . storage val thisLength = thisStorage . len ( ) val copy = WasmCharArray ( thisLength ) copyWasmArray ( this . storage , copy , , , thisLength ) return copy . createString ( ) }","docstring":"/**\n * Concatenates characters in this [CharArray] into a String.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" ) public actual fun CharArray . concatToString ( startIndex : Int = , endIndex : Int = this . size ) : String","body":"{ AbstractList . checkBoundsIndexes ( startIndex , endIndex , this . size ) val length = endIndex - startIndex val copy = WasmCharArray ( length ) copyWasmArray ( this . storage , copy , startIndex , , length ) return copy . createString ( ) }","docstring":"/**\n * Concatenates characters in this [CharArray] or its subrange into a String.\n *\n * @param startIndex the beginning (inclusive) of the subrange of characters, 0 by default.\n * @param endIndex the end (exclusive) of the subrange of characters, size of this array by default.\n *\n * @throws IndexOutOfBoundsException if [startIndex] is less than zero or [endIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [startIndex] is greater than [endIndex].\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual fun String . toCharArray ( ) : CharArray","body":"{ val thisChars = this . chars val thisLength = thisChars . len ( ) val newArray = CharArray ( thisLength ) copyWasmArray ( thisChars , newArray . storage , , , thisLength ) return newArray }","docstring":"/**\n * Returns a [CharArray] containing characters of this string.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" ) public actual fun String . toCharArray ( startIndex : Int = , endIndex : Int = this . length ) : CharArray","body":"{ AbstractList . checkBoundsIndexes ( startIndex , endIndex , length ) val newLength = endIndex - startIndex val newArray = CharArray ( newLength ) copyWasmArray ( this . chars , newArray . storage , startIndex , , newLength ) return newArray }","docstring":"/**\n * Returns a [CharArray] containing characters of this string or its substring.\n *\n * @param startIndex the beginning (inclusive) of the substring, 0 by default.\n * @param endIndex the end (exclusive) of the substring, length of this string by default.\n *\n * @throws IndexOutOfBoundsException if [startIndex] is less than zero or [endIndex] is greater than the length of this string.\n * @throws IllegalArgumentException if [startIndex] is greater than [endIndex].\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" ) public actual fun String . toCharArray ( destination : CharArray , destinationOffset : Int = , startIndex : Int = , endIndex : Int = length ) : CharArray","body":"{ AbstractList . checkBoundsIndexes ( startIndex , endIndex , length ) val rangeSize = endIndex - startIndex AbstractList . checkBoundsIndexes ( destinationOffset , destinationOffset + rangeSize , destination . size ) copyWasmArray ( this . chars , destination . storage , startIndex , destinationOffset , rangeSize ) return destination }","docstring":"/**\n * Copies characters from this string into the [destination] character array and returns that array.\n *\n * @param destination the array to copy to.\n * @param destinationOffset the position in the array to copy to.\n * @param startIndex the start offset (inclusive) of the substring to copy.\n * @param endIndex the end offset (exclusive) of the substring to copy.\n *\n * @throws IndexOutOfBoundsException or [IllegalArgumentException] when [startIndex] or [endIndex] is out of range of this string builder indices or when `startIndex > endIndex`.\n * @throws IndexOutOfBoundsException when the subrange doesn't fit into the [destination] array starting at the specified [destinationOffset],\n * or when that index is out of the [destination] array indices range.\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual fun ByteArray . decodeToString ( ) : String","body":"{ return decodeUtf8 ( this , , size , false ) }","docstring":"/**\n * Decodes a string from the bytes in UTF-8 encoding in this array.\n *\n * Malformed byte sequences are replaced by the replacement char `\\uFFFD`.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" ) public actual fun ByteArray . decodeToString ( startIndex : Int = , endIndex : Int = this . size , throwOnInvalidSequence : Boolean = false ) : String","body":"{ AbstractList . checkBoundsIndexes ( startIndex , endIndex , this . size ) return decodeUtf8 ( this , startIndex , endIndex , throwOnInvalidSequence ) }","docstring":"/**\n * Decodes a string from the bytes in UTF-8 encoding in this array or its subrange.\n *\n * @param startIndex the beginning (inclusive) of the subrange to decode, 0 by default.\n * @param endIndex the end (exclusive) of the subrange to decode, size of this array by default.\n * @param throwOnInvalidSequence specifies whether to throw an exception on malformed byte sequence or replace it by the replacement char `\\uFFFD`.\n *\n * @throws IndexOutOfBoundsException if [startIndex] is less than zero or [endIndex] is greater than the size of this array.\n * @throws IllegalArgumentException if [startIndex] is greater than [endIndex].\n * @throws CharacterCodingException if the byte array contains malformed UTF-8 byte sequence and [throwOnInvalidSequence] is true.\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual fun String . encodeToByteArray ( ) : ByteArray","body":"{ return encodeUtf8 ( this , , length , false ) }","docstring":"/**\n * Encodes this string to an array of bytes in UTF-8 encoding.\n *\n * Any malformed char sequence is replaced by the replacement byte sequence.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" ) public actual fun String . encodeToByteArray ( startIndex : Int = , endIndex : Int = this . length , throwOnInvalidSequence : Boolean = false ) : ByteArray","body":"{ AbstractList . checkBoundsIndexes ( startIndex , endIndex , length ) return encodeUtf8 ( this , startIndex , endIndex , throwOnInvalidSequence ) }","docstring":"/**\n * Encodes this string or its substring to an array of bytes in UTF-8 encoding.\n *\n * @param startIndex the beginning (inclusive) of the substring to encode, 0 by default.\n * @param endIndex the end (exclusive) of the substring to encode, length of this string by default.\n * @param throwOnInvalidSequence specifies whether to throw an exception on malformed char sequence or replace.\n *\n * @throws IndexOutOfBoundsException if [startIndex] is less than zero or [endIndex] is greater than the length of this string.\n * @throws IllegalArgumentException if [startIndex] is greater than [endIndex].\n * @throws CharacterCodingException if this string contains malformed char sequence and [throwOnInvalidSequence] is true.\n */"} {"signature":"public actual fun String . substring ( startIndex : Int ) : String","body":"= subSequence ( startIndex , this . length ) as String","docstring":"/**\n * Returns a substring of this string that starts at the specified [startIndex] and continues to the end of the string.\n */"} {"signature":"public actual fun String . substring ( startIndex : Int , endIndex : Int ) : String","body":"= subSequence ( startIndex , endIndex ) as String","docstring":"/**\n * Returns the substring of this string starting at the [startIndex] and ending right before the [endIndex].\n *\n * @param startIndex the start index (inclusive).\n * @param endIndex the end index (exclusive).\n */"} {"signature":"@ Deprecated ( \"\" , ReplaceWith ( \"\" ) ) @ DeprecatedSinceKotlin ( warningSince = \"\" ) public actual fun String . toUpperCase ( ) : String","body":"= uppercase ( )","docstring":"/**\n * Returns a copy of this string converted to upper case using the rules of the default locale.\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual fun String . uppercase ( ) : String","body":"= uppercaseImpl ( )","docstring":"/**\n * Returns a copy of this string converted to upper case using Unicode mapping rules of the invariant locale.\n *\n * This function supports one-to-many and many-to-one character mapping,\n * thus the length of the returned string can be different from the length of the original string.\n *\n * @sample samples.text.Strings.uppercase\n */"} {"signature":"@ Deprecated ( \"\" , ReplaceWith ( \"\" ) ) @ DeprecatedSinceKotlin ( warningSince = \"\" ) public actual fun String . toLowerCase ( ) : String","body":"= lowercase ( )","docstring":"/**\n * Returns a copy of this string converted to lower case using the rules of the default locale.\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual fun String . lowercase ( ) : String","body":"= lowercaseImpl ( )","docstring":"/**\n * Returns a copy of this string converted to lower case using Unicode mapping rules of the invariant locale.\n *\n * This function supports one-to-many and many-to-one character mapping,\n * thus the length of the returned string can be different from the length of the original string.\n *\n * @sample samples.text.Strings.lowercase\n */"} {"signature":"@ Deprecated ( \"\" , ReplaceWith ( \"\" ) ) @ DeprecatedSinceKotlin ( warningSince = \"\" ) public actual fun String . capitalize ( ) : String","body":"= replaceFirstChar ( Char :: uppercaseChar )","docstring":"/**\n * Returns a copy of this string having its first letter titlecased using the rules of the default locale,\n * or the original string if it's empty or already starts with a title case letter.\n *\n * The title case of a character is usually the same as its upper case with several exceptions.\n * The particular list of characters with the special title case form depends on the underlying platform.\n *\n * @sample samples.text.Strings.capitalize\n */"} {"signature":"@ Deprecated ( \"\" , ReplaceWith ( \"\" ) ) @ DeprecatedSinceKotlin ( warningSince = \"\" ) public actual fun String . decapitalize ( ) : String","body":"= replaceFirstChar ( Char :: lowercaseChar )","docstring":"/**\n * Returns a copy of this string having its first letter lowercased using the rules of the default locale,\n * or the original string if it's empty or already starts with a lower case letter.\n *\n * @sample samples.text.Strings.decapitalize\n */"} {"signature":"public actual fun CharSequence . repeat ( n : Int ) : String","body":"{ require ( n >= ) { \"\" } if ( isEmpty ( ) ) return \"\" return when ( n ) { -> \"\" -> this . toString ( ) else -> { val sequence = this buildString ( n * length ) { repeat ( n ) { append ( sequence ) } } } } }","docstring":"/**\n * Returns a string containing this char sequence repeated [n] times.\n * @throws [IllegalArgumentException] when n < 0.\n * @sample samples.text.Strings.repeat\n */"} {"signature":"@ Suppress ( \"\" ) public actual fun String . replace ( oldChar : Char , newChar : Char , ignoreCase : Boolean = false ) : String","body":"{ return buildString ( length ) { this@replace . forEach { c -> append ( if ( c . equals ( oldChar , ignoreCase ) ) newChar else c ) } } }","docstring":"/**\n * Returns a new string with all occurrences of [oldChar] replaced with [newChar].\n */"} {"signature":"@ Suppress ( \"\" ) public actual fun String . replace ( oldValue : String , newValue : String , ignoreCase : Boolean = false ) : String","body":"{ run { var occurrenceIndex : Int = indexOf ( oldValue , , ignoreCase ) if ( occurrenceIndex < ) return this val oldValueLength = oldValue . length val searchStep = oldValueLength . coerceAtLeast ( ) val newLengthHint = length - oldValueLength + newValue . length if ( newLengthHint < ) throw OutOfMemoryError ( ) val stringBuilder = StringBuilder ( newLengthHint ) var i = do { stringBuilder . append ( this , i , occurrenceIndex ) . append ( newValue ) i = occurrenceIndex + oldValueLength if ( occurrenceIndex >= length ) break occurrenceIndex = indexOf ( oldValue , occurrenceIndex + searchStep , ignoreCase ) } while ( occurrenceIndex > ) return stringBuilder . append ( this , i , length ) . toString ( ) } }","docstring":"/**\n * Returns a new string obtained by replacing all occurrences of the [oldValue] substring in this string\n * with the specified [newValue] string.\n */"} {"signature":"@ Suppress ( \"\" ) public actual fun String . replaceFirst ( oldChar : Char , newChar : Char , ignoreCase : Boolean = false ) : String","body":"{ val index = indexOf ( oldChar , ignoreCase = ignoreCase ) return if ( index < ) this else this . replaceRange ( index , index + , newChar . toString ( ) ) }","docstring":"/**\n * Returns a new string with the first occurrence of [oldChar] replaced with [newChar].\n */"} {"signature":"@ Suppress ( \"\" ) public actual fun String . replaceFirst ( oldValue : String , newValue : String , ignoreCase : Boolean = false ) : String","body":"{ val index = indexOf ( oldValue , ignoreCase = ignoreCase ) return if ( index < ) this else this . replaceRange ( index , index + oldValue . length , newValue ) }","docstring":"/**\n * Returns a new string obtained by replacing the first occurrence of the [oldValue] substring in this string\n * with the specified [newValue] string.\n */"} {"signature":"@ Suppress ( \"\" ) public actual fun String ? . equals ( other : String ? , ignoreCase : Boolean = false ) : Boolean","body":"{ if ( this == null ) return other == null if ( other == null ) return false if ( ! ignoreCase ) return this == other if ( this . length != other . length ) return false for ( index in until this . length ) { val thisChar = this [ index ] val otherChar = other [ index ] if ( ! thisChar . equals ( otherChar , ignoreCase ) ) { return false } } return true }","docstring":"/**\n * Returns `true` if this string is equal to [other], optionally ignoring character case.\n *\n * Two strings are considered to be equal if they have the same length and the same character at the same index.\n * If [ignoreCase] is true, the result of `Char.uppercaseChar().lowercaseChar()` on each character is compared.\n *\n * @param ignoreCase `true` to ignore character case when comparing strings. By default `false`.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" ) public actual fun String . compareTo ( other : String , ignoreCase : Boolean = false ) : Int","body":"{ if ( ignoreCase ) { val n1 = this . length val n2 = other . length val min = minOf ( n1 , n2 ) if ( min == ) return n1 - n2 for ( index in until min ) { var thisChar = this [ index ] var otherChar = other [ index ] if ( thisChar != otherChar ) { thisChar = thisChar . uppercaseChar ( ) otherChar = otherChar . uppercaseChar ( ) if ( thisChar != otherChar ) { thisChar = thisChar . lowercaseChar ( ) otherChar = otherChar . lowercaseChar ( ) if ( thisChar != otherChar ) { return thisChar . compareTo ( otherChar ) } } } } return n1 - n2 } else { return compareTo ( other ) } }","docstring":"/**\n * Compares two strings lexicographically, optionally ignoring case differences.\n *\n * If [ignoreCase] is true, the result of `Char.uppercaseChar().lowercaseChar()` on each character is compared.\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual infix fun CharSequence ? . contentEquals ( other : CharSequence ? ) : Boolean","body":"= contentEqualsImpl ( other )","docstring":"/**\n * Returns `true` if the contents of this char sequence are equal to the contents of the specified [other],\n * i.e. both char sequences contain the same number of the same characters in the same order.\n *\n * @sample samples.text.Strings.contentEquals\n */"} {"signature":"@ SinceKotlin ( \"\" ) public actual fun CharSequence ? . contentEquals ( other : CharSequence ? , ignoreCase : Boolean ) : Boolean","body":"{ return if ( ignoreCase ) this . contentEqualsIgnoreCaseImpl ( other ) else this . contentEqualsImpl ( other ) }","docstring":"/**\n * Returns `true` if the contents of this char sequence are equal to the contents of the specified [other], optionally ignoring case difference.\n *\n * @param ignoreCase `true` to ignore character case when comparing contents.\n *\n * @sample samples.text.Strings.contentEquals\n */"} {"signature":"@ Suppress ( \"\" ) public actual fun String . startsWith ( prefix : String , ignoreCase : Boolean = false ) : Boolean","body":"= regionMatches ( , prefix , , prefix . length , ignoreCase )","docstring":"/**\n * Returns `true` if this string starts with the specified prefix.\n */"} {"signature":"@ Suppress ( \"\" ) public actual fun String . startsWith ( prefix : String , startIndex : Int , ignoreCase : Boolean = false ) : Boolean","body":"= regionMatches ( startIndex , prefix , , prefix . length , ignoreCase )","docstring":"/**\n * Returns `true` if a substring of this string starting at the specified offset [startIndex] starts with the specified prefix.\n */"} {"signature":"@ Suppress ( \"\" ) public actual fun String . endsWith ( suffix : String , ignoreCase : Boolean = false ) : Boolean","body":"= regionMatches ( length - suffix . length , suffix , , suffix . length , ignoreCase )","docstring":"/**\n * Returns `true` if this string ends with the specified suffix.\n */"} {"signature":"public actual fun CharSequence . regionMatches ( thisOffset : Int , other : CharSequence , otherOffset : Int , length : Int , ignoreCase : Boolean ) : Boolean","body":"= regionMatchesImpl ( thisOffset , other , otherOffset , length , ignoreCase )","docstring":"/**\n * Returns `true` if the specified range in this char sequence is equal to the specified range in another char sequence.\n * @param thisOffset the start offset in this char sequence of the substring to compare.\n * @param other the string against a substring of which the comparison is performed.\n * @param otherOffset the start offset in the other char sequence of the substring to compare.\n * @param length the length of the substring to compare.\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ Suppress ( \"\" ) public actual fun String . regionMatches ( thisOffset : Int , other : String , otherOffset : Int , length : Int , ignoreCase : Boolean = false ) : Boolean","body":"= regionMatchesImpl ( thisOffset , other , otherOffset , length , ignoreCase )","docstring":"/**\n * Returns `true` if the specified range in this string is equal to the specified range in another string.\n * @param thisOffset the start offset in this string of the substring to compare.\n * @param other the string against a substring of which the comparison is performed.\n * @param otherOffset the start offset in the other string of the substring to compare.\n * @param length the length of the substring to compare.\n */"} {"signature":"fun lenetWithEarlyStoppingCallback ( )","body":"{ val ( train , test ) = mnist ( ) lenet5Classic . use { val earlyStopping = EarlyStopping ( monitor = EpochTrainingEvent :: valLossValue , minDelta = , patience = , verbose = true , mode = EarlyStoppingMode . AUTO , baseline = , restoreBestWeights = false ) it . compile ( optimizer = Adam ( clipGradient = ClipGradientByValue ( ) ) , loss = Losses . SOFT_MAX_CROSS_ENTROPY_WITH_LOGITS , metric = Metrics . ACCURACY ) it . logSummary ( ) it . fit ( dataset = train , epochs = EPOCHS , batchSize = TRAINING_BATCH_SIZE , earlyStopping ) val accuracy = it . evaluate ( dataset = test , batchSize = TEST_BATCH_SIZE ) . metrics [ Metrics . ACCURACY ] println ( \"\" ) } }","docstring":"/**\n * This example shows how to do image classification from scratch using [lenet5Classic], without leveraging pre-trained weights or a pre-made model.\n * We demonstrate the workflow on the Mnist classification dataset.\n *\n * It includes:\n * - dataset loading from S3\n * - callback definition\n * - model compilation with [EarlyStopping] callback\n * - model summary\n * - model training\n * - model evaluation\n */"} {"signature":"fun main ( ) : Unit","body":"= lenetWithEarlyStoppingCallback ( )","docstring":"/** */"} {"signature":"fun append ( charCode : Int , categoryId : String ) : Boolean","body":"fun append ( charCode : Int , categoryId : String ) : Boolean","docstring":"/**\n * Appends the [charCode] to this range pattern.\n * Returns true if the [charCode] with the specified [categoryId] could be accommodated within this pattern.\n * Returns false otherwise.\n */"} {"signature":"fun prepend ( charCode : Int , categoryId : String ) : Boolean","body":"fun prepend ( charCode : Int , categoryId : String ) : Boolean","docstring":"/**\n * Prepends the [charCode] to this range pattern.\n * Returns true if the [charCode] with the specified [categoryId] could be accommodated within this pattern.\n * Returns false otherwise.\n */"} {"signature":"fun rangeStart ( ) : Int","body":"fun rangeStart ( ) : Int","docstring":"/**\n * Char code of the first char in this range.\n */"} {"signature":"fun rangeEnd ( ) : Int","body":"fun rangeEnd ( ) : Int","docstring":"/**\n * Char code of the last char in this range.\n */"} {"signature":"fun category ( ) : Int","body":"fun category ( ) : Int","docstring":"/**\n * An integer value that contains information about the category of each char in this range.\n */"} {"signature":"fun categoryIdOf ( charCode : Int ) : String","body":"fun categoryIdOf ( charCode : Int ) : String","docstring":"/**\n * Returns category id of the char with the specified [charCode].\n * Throws an exception if the [charCode] is not in `rangeStart()..rangeEnd()`.\n */"} {"signature":"operator fun Product . contains ( item : Any ? ) : Boolean","body":"= productIterator ( ) . contains ( item )","docstring":"/** Tests whether this iterator contains a given value as an element.\n * Note: may not terminate for infinite iterators.\n *\n * @param item the element to test.\n * @return `true` if this iterator produces some value that\n * is equal (as determined by `==`) to `elem`, `false` otherwise.\n * @note Reuse: After calling this method, one should discard the iterator it was called on.\n * Using it is undefined and subject to change.\n */"} {"signature":"operator fun Product . iterator ( ) : Iterator < Any ? >","body":"= JavaConverters . asJavaIterator ( productIterator ( ) )","docstring":"/**\n * An iterator over all the elements of this product.\n * @return in the default implementation, an `Iterator`\n */"} {"signature":"fun Product . asIterable ( ) : Iterable < Any ? >","body":"= object : Iterable < Any ? > { override fun iterator ( ) : Iterator < Any ? > = JavaConverters . asJavaIterator ( productIterator ( ) ) }","docstring":"/**\n * Converts this product to an `Any?` iterable.\n */"} {"signature":"@ Throws ( IndexOutOfBoundsException :: class ) operator fun Product . get ( n : Int ) : Any ?","body":"= productElement ( n )","docstring":"/** The n'th element of this product, 0-based. In other words, for a\n * product `A(x,,1,,, ..., x,,k,,)`, returns `x,,(n+1),,` where `0 <= n < k`.\n *\n * @param n the index of the element to return\n * @throws IndexOutOfBoundsException\n * @return the element `n` elements after the first element\n */"} {"signature":"fun Product . getOrNull ( n : Int ) : Any ?","body":"= if ( n in until size ) productElement ( n ) else null","docstring":"/** The n'th element of this product, 0-based. In other words, for a\n * product `A(x,,1,,, ..., x,,k,,)`, returns `x,,(n+1),,` where `0 <= n < k`.\n *\n * @param n the index of the element to return\n * @return the element `n` elements after the first element, `null` if out of bounds\n */"} {"signature":"@ Suppress ( \"\" ) @ Throws ( IndexOutOfBoundsException :: class , ClassCastException :: class ) inline fun < reified T > Product . getAs ( n : Int ) : T","body":"= productElement ( n ) as T","docstring":"/** The n'th element of this product, 0-based. In other words, for a\n * product `A(x,,1,,, ..., x,,k,,)`, returns `x,,(n+1),,` where `0 <= n < k`.\n * The result is cast to the given type [T].\n *\n * @param n the index of the element to return\n * @throws IndexOutOfBoundsException\n * @throws ClassCastException\n * @return the element `n` elements after the first element\n */"} {"signature":"@ Suppress ( \"\" ) inline fun < reified T > Product . getAsOrNull ( n : Int ) : T ?","body":"= getOrNull ( n ) as? T","docstring":"/** The n'th element of this product, 0-based. In other words, for a\n * product `A(x,,1,,, ..., x,,k,,)`, returns `x,,(n+1),,` where `0 <= n < k`.\n * The result is cast to the given type [T].\n *\n * @param n the index of the element to return\n * @return the element `n` elements after the first element, `null` if out of bounds or unable to be cast\n */"} {"signature":"@ Throws ( IndexOutOfBoundsException :: class ) operator fun Product . get ( indexRange : IntRange ) : List < Any ? >","body":"= indexRange . map ( :: get )","docstring":"/** The range of n'th elements of this product, 0-based. In other words, for a\n * product `A(x,,1,,, ..., x,,k,,)`, returns `x,,(n+1),,` where `0 <= n < k`.\n *\n * @param indexRange the indices of the elements to return\n * @throws IndexOutOfBoundsException\n * @return the elements in [indexRange]\n */"} {"signature":"fun Product . getOrNull ( indexRange : IntRange ) : List < Any ? >","body":"= indexRange . map ( :: getOrNull )","docstring":"/** The range of n'th elements of this product, 0-based. In other words, for a\n * product `A(x,,1,,, ..., x,,k,,)`, returns `x,,(n+1),,` where `0 <= n < k`.\n *\n * @param indexRange the indices of the elements to return\n * @return the elements in [indexRange], `null` if out of bounds\n */"} {"signature":"@ Throws ( IndexOutOfBoundsException :: class , ClassCastException :: class ) inline fun < reified T > Product . getAs ( indexRange : IntRange ) : List < T >","body":"= indexRange . map ( :: getAs )","docstring":"/** The range of n'th elements of this product, 0-based. In other words, for a\n * product `A(x,,1,,, ..., x,,k,,)`, returns `x,,(n+1),,` where `0 <= n < k`.\n * The results are cast to the given type [T].\n *\n * @param indexRange the indices of the elements to return\n * @throws IndexOutOfBoundsException\n * @throws ClassCastException\n * @return the elements in [indexRange]\n */"} {"signature":"inline fun < reified T > Product . getAsOrNull ( indexRange : IntRange ) : List < T ? >","body":"= indexRange . map ( :: getAsOrNull )","docstring":"/** The range of n'th elements of this product, 0-based. In other words, for a\n * product `A(x,,1,,, ..., x,,k,,)`, returns `x,,(n+1),,` where `0 <= n < k`.\n * The results are cast to the given type [T].\n *\n * @param indexRange the indices of the elements to return\n * @return the elements in [indexRange], `null` is out of bounds or unable to be cast\n */"} {"signature":"fun getConstraintsContainedSpecifiedTypeVariable ( typeVariableConstructor : TypeConstructorMarker ) : Collection < Constraint >","body":"fun getConstraintsContainedSpecifiedTypeVariable ( typeVariableConstructor : TypeConstructorMarker ) : Collection < Constraint >","docstring":"/**\n * Only necessary for incorporation optimization\n */"} {"signature":"@ Test fun testResumingFromAnotherThread ( )","body":"= runTest { suspendCancellableCoroutine < Unit > { cont -> thread { Thread . sleep ( ) cont . resume ( Unit ) } } }","docstring":"/** Tests that resuming the coroutine of [runTest] asynchronously in reasonable time succeeds. */"} {"signature":"@ Test fun testStandardTestDispatcherIsConfined ( ) : Unit","body":"= runBlocking { val scheduler = TestCoroutineScheduler ( ) val initialThread = Thread . currentThread ( ) val job = launch ( StandardTestDispatcher ( scheduler ) ) { assertEquals ( initialThread , Thread . currentThread ( ) ) withContext ( Dispatchers . IO ) { val ioThread = Thread . currentThread ( ) assertNotSame ( initialThread , ioThread ) } assertEquals ( initialThread , Thread . currentThread ( ) ) } scheduler . advanceUntilIdle ( ) while ( job . isActive ) { scheduler . receiveDispatchEvent ( ) scheduler . advanceUntilIdle ( ) } }","docstring":"/** Tests that [StandardTestDispatcher] is not executed in-place but confined to the thread in which the\n * virtual time control happens. */"} {"signature":"public fun thread ( start : Boolean = true , isDaemon : Boolean = false , contextClassLoader : ClassLoader ? = null , name : String ? = null , priority : Int = - , block : ( ) -> Unit ) : Thread","body":"{ val thread = object : Thread ( ) { public override fun run ( ) { block ( ) } } if ( isDaemon ) thread . isDaemon = true if ( priority > ) thread . priority = priority if ( name != null ) thread . name = name if ( contextClassLoader != null ) thread . contextClassLoader = contextClassLoader if ( start ) thread . start ( ) return thread }","docstring":"/**\n * Creates a thread that runs the specified [block] of code.\n *\n * @param start if `true`, the thread is immediately started.\n * @param isDaemon if `true`, the thread is created as a daemon thread. The Java Virtual Machine exits when\n * the only threads running are all daemon threads.\n * @param contextClassLoader the class loader to use for loading classes and resources in this thread.\n * @param name the name of the thread.\n * @param priority the priority of the thread.\n */"} {"signature":"@ kotlin . internal . InlineOnly public inline fun < T : Any > ThreadLocal < T > . getOrSet ( default : ( ) -> T ) : T","body":"{ return get ( ) ? : default ( ) . also ( this :: set ) }","docstring":"/**\n * Gets the value in the current thread's copy of this\n * thread-local variable or replaces the value with the result of calling\n * [default] function in case if that value was `null`.\n *\n * If the variable has no value for the current thread,\n * it is first initialized to the value returned\n * by an invocation of the [ThreadLocal.initialValue] method.\n * Then if it is still `null`, the provided [default] function is called and its result\n * is stored for the current thread and then returned.\n */"} {"signature":"fun x ( )","body":"{ }","docstring":"/**\n * [LazyThreadSafetyMode.PUBLICATION]\n */"} {"signature":"fun lenetOnMnistInferenceWithTensorNames ( )","body":"{ val ( train , test ) = mnist ( ) SavedModel . load ( PATH_TO_MODEL ) . use { println ( it . graphToString ( ) ) val prediction = it . predict ( train . getX ( ) , \"\" , \"\" ) println ( \"\" ) println ( \"\" + train . getY ( ) ) val predictions = it . predict ( test ) { data -> predict ( data , \"\" , \"\" ) } println ( predictions . toString ( ) ) println ( \"\" ) } }","docstring":"/**\n * This examples demonstrates running [SavedModel] for prediction on [mnist] dataset.\n *\n * It uses string tensor names to get access to input/output tensors in TensorFlow static graph.\n */"} {"signature":"fun main ( ) : Unit","body":"= lenetOnMnistInferenceWithTensorNames ( )","docstring":"/** */"} {"signature":"public fun append ( value : Char ) : Appendable","body":"public fun append ( value : Char ) : Appendable","docstring":"/**\n * Appends the specified character [value] to this Appendable and returns this instance.\n *\n * @param value the character to append.\n */"} {"signature":"public fun append ( value : CharSequence ? ) : Appendable","body":"public fun append ( value : CharSequence ? ) : Appendable","docstring":"/**\n * Appends the specified character sequence [value] to this Appendable and returns this instance.\n *\n * @param value the character sequence to append. If [value] is `null`, then the four characters `\"null\"` are appended to this Appendable.\n */"} {"signature":"public fun append ( value : CharSequence ? , startIndex : Int , endIndex : Int ) : Appendable","body":"public fun append ( value : CharSequence ? , startIndex : Int , endIndex : Int ) : Appendable","docstring":"/**\n * Appends a subsequence of the specified character sequence [value] to this Appendable and returns this instance.\n *\n * @param value the character sequence from which a subsequence is appended. If [value] is `null`,\n * then characters are appended as if [value] contained the four characters `\"null\"`.\n * @param startIndex the beginning (inclusive) of the subsequence to append.\n * @param endIndex the end (exclusive) of the subsequence to append.\n *\n * @throws IndexOutOfBoundsException or [IllegalArgumentException] when [startIndex] or [endIndex] is out of range of the [value] character sequence indices or when `startIndex > endIndex`.\n */"} {"signature":"@ SinceKotlin ( \"\" ) public fun < T : Appendable > T . appendRange ( value : CharSequence , startIndex : Int , endIndex : Int ) : T","body":"{ @ Suppress ( \"\" ) return append ( value , startIndex , endIndex ) as T }","docstring":"/**\n * Appends a subsequence of the specified character sequence [value] to this Appendable and returns this instance.\n *\n * @param value the character sequence from which a subsequence is appended.\n * @param startIndex the beginning (inclusive) of the subsequence to append.\n * @param endIndex the end (exclusive) of the subsequence to append.\n *\n * @throws IndexOutOfBoundsException or [IllegalArgumentException] when [startIndex] or [endIndex] is out of range of the [value] character sequence indices or when `startIndex > endIndex`.\n */"} {"signature":"public fun < T : Appendable > T . append ( vararg value : CharSequence ? ) : T","body":"{ for ( item in value ) append ( item ) return this }","docstring":"/**\n * Appends all arguments to the given [Appendable].\n */"} {"signature":"@ SinceKotlin ( \"\" ) @ kotlin . internal . InlineOnly public inline fun Appendable . appendLine ( ) : Appendable","body":"= append ( '' )","docstring":"/** Appends a line feed character (`\\n`) to this Appendable. */"} {"signature":"@ SinceKotlin ( \"\" ) @ kotlin . internal . InlineOnly public inline fun Appendable . appendLine ( value : CharSequence ? ) : Appendable","body":"= append ( value ) . appendLine ( )","docstring":"/** Appends value to the given Appendable and a line feed character (`\\n`) after it. */"} {"signature":"@ SinceKotlin ( \"\" ) @ kotlin . internal . InlineOnly public inline fun Appendable . appendLine ( value : Char ) : Appendable","body":"= append ( value ) . appendLine ( )","docstring":"/** Appends value to the given Appendable and a line feed character (`\\n`) after it. */"} {"signature":"internal fun decompiledText ( file : FileWithMetadata . Compatible , serializerProtocol : SerializerExtensionProtocol , flexibleTypeDeserializer : FlexibleTypeDeserializer , renderer : DescriptorRenderer , deserializationConfiguration : DeserializationConfiguration = DeserializationConfiguration . Default ) : DecompiledText","body":"{ val packageFqName = file . packageFqName val resolver = KlibMetadataDeserializerForDecompiler ( packageFqName , file . proto , file . nameResolver , serializerProtocol , flexibleTypeDeserializer , deserializationConfiguration , ) val declarations = arrayListOf < DeclarationDescriptor > ( ) declarations . addAll ( resolver . resolveDeclarationsInFacade ( packageFqName ) ) for ( classProto in file . classesToDecompile ) { val classId = file . nameResolver . getClassId ( classProto . fqName ) declarations . addIfNotNull ( resolver . resolveTopLevelClass ( classId ) ) } return buildDecompiledText ( packageFqName , declarations , renderer ) }","docstring":"/**\n * This function is extracted for [Fe10KlibMetadataDecompiler], [Fe10KlibMetadataStubBuilder] and [K2KlibMetadataDecompiler].\n * TODO: K2 shouldn't use descriptor renderer for building decompiled text.\n * Note that decompiled text is not used for building stubs in K2.\n * That's why in K2 it is important to preserve declaration order during deserialization to not get PSI vs. stubs mismatch.\n */"} {"signature":"fun getPreviewImageBounds ( sourceImageWidth : Int , sourceImageHeight : Int , viewWidth : Int , viewHeight : Int , scaleType : PreviewView . ScaleType ) : PreviewImageBounds","body":"{ val scale = if ( scaleType == PreviewView . ScaleType . FILL_START || scaleType == PreviewView . ScaleType . FILL_END || scaleType == PreviewView . ScaleType . FILL_CENTER ) { max ( viewWidth . toFloat ( ) / sourceImageWidth , viewHeight . toFloat ( ) / sourceImageHeight ) } else { min ( viewWidth . toFloat ( ) / sourceImageWidth , viewHeight . toFloat ( ) / sourceImageHeight ) } val previewImageWidth = sourceImageWidth * scale val previewImageHeight = sourceImageHeight * scale return when ( scaleType ) { PreviewView . ScaleType . FILL_START , PreviewView . ScaleType . FIT_START -> { PreviewImageBounds ( , , previewImageWidth , previewImageHeight ) } PreviewView . ScaleType . FILL_END , PreviewView . ScaleType . FIT_END -> { PreviewImageBounds ( viewWidth - previewImageWidth , viewHeight - previewImageHeight , previewImageWidth , previewImageHeight ) } else -> { PreviewImageBounds ( viewWidth / - previewImageWidth / , viewHeight / - previewImageHeight / , previewImageWidth , previewImageHeight ) } } }","docstring":"/**\n * Calculate the location of the preview image top-left corner (relative to the component top-left corner)\n * and dimensions, to be used for displaying detected objects, for example with the [DetectorViewBase].\n *\n * When camera preview resolution differs from the dimensions of the [PreviewView] used to display camera input,\n * image is scaled and cropped or padded according to the provided [PreviewView.ScaleType]. Because of this,\n * in order to display detected objects on the [PreviewView], their coordinates need to be converted.\n * This method returns [PreviewImageBounds] object containing the necessary information to preform the conversion\n * from the image coordinate system to the view coordinate system.\n *\n * @param [sourceImageWidth] width of the image from the camera\n * @param [sourceImageHeight] height of the image from the camera\n * @param [viewWidth] width of the target [PreviewView]\n * @param [viewHeight] height of the target [PreviewView]\n * @param [scaleType] scaling option used in the target [PreviewView]\n *\n * @see Scale type\n */"} {"signature":"internal fun generateKotlinVersion ( apiDir : File , filePrinter : ( targetFile : File , Printer . ( ) -> Unit ) -> Unit )","body":"{ val kotlinVersionFqName = FqName ( \"\" ) filePrinter ( fileFromFqName ( apiDir , kotlinVersionFqName ) ) { generateDeclaration ( \"\" , kotlinVersionFqName , afterType = \"\" ) { for ( languageVersion in LanguageVersion . values ( ) ) { val prefix = when { languageVersion . isUnsupported -> \"\" languageVersion . isDeprecated -> \"\" else -> \"\" } println ( \"\" ) } println ( \"\" ) println ( ) println ( \"\" ) withIndent { println ( \"\" ) println ( \"\" ) println ( \"\" ) println ( \"\" ) println ( ) println ( \"\" ) println ( \"\" ) } println ( \"\" ) } } }","docstring":"/**\n * ApiVersion and LanguageVersion are almost the same in the compiler api, so Gradle DSL options\n * exposes KotlinVersion that covers both of them.\n */"} {"signature":"public fun chars ( value : String )","body":"public fun chars ( value : String )","docstring":"/**\n * A literal string.\n *\n * When formatting, the string is appended to the result as is,\n * and when parsing, the string is expected to be present in the input verbatim.\n */"} {"signature":"public fun year ( padding : Padding = Padding . ZERO )","body":"public fun year ( padding : Padding = Padding . ZERO )","docstring":"/**\n * A year number.\n *\n * By default, for years [-9999..9999], it's formatted as a decimal number, zero-padded to four digits, though\n * this padding can be disabled or changed to space padding by passing [padding].\n * For years outside this range, it's formatted as a decimal number with a leading sign, so the year 12345\n * is formatted as \"+12345\".\n */"} {"signature":"public fun yearTwoDigits ( baseYear : Int )","body":"public fun yearTwoDigits ( baseYear : Int )","docstring":"/**\n * The last two digits of the ISO year.\n *\n * [baseYear] is the base year for the two-digit year.\n * For example, if [baseYear] is 1960, then this format correctly works with years [1960..2059].\n *\n * On formatting, when given a year in the valid range, it returns the last two digits of the year,\n * so 1993 becomes \"93\". When given a year outside the valid range, it returns the full year number\n * with a leading sign, so 1850 becomes \"+1850\", and -200 becomes \"-200\".\n *\n * On parsing, it accepts either a two-digit year or a full year number with a leading sign.\n * When given a two-digit year, it returns a year in the valid range, so \"93\" becomes 1993,\n * and when given a full year number with a leading sign, it parses the full year number,\n * so \"+1850\" becomes 1850.\n */"} {"signature":"public fun monthNumber ( padding : Padding = Padding . ZERO )","body":"public fun monthNumber ( padding : Padding = Padding . ZERO )","docstring":"/**\n * A month-of-year number, from 1 to 12.\n *\n * By default, it's padded with zeros to two digits. This can be changed by passing [padding].\n */"} {"signature":"public fun monthName ( names : MonthNames )","body":"public fun monthName ( names : MonthNames )","docstring":"/**\n * A month name (for example, \"January\").\n *\n * Example:\n * ```\n * monthName(MonthNames.ENGLISH_FULL)\n * ```\n */"} {"signature":"public fun dayOfMonth ( padding : Padding = Padding . ZERO )","body":"public fun dayOfMonth ( padding : Padding = Padding . ZERO )","docstring":"/**\n * A day-of-month number, from 1 to 31.\n *\n * By default, it's padded with zeros to two digits. This can be changed by passing [padding].\n */"} {"signature":"public fun dayOfWeek ( names : DayOfWeekNames )","body":"public fun dayOfWeek ( names : DayOfWeekNames )","docstring":"/**\n * A day-of-week name (for example, \"Thursday\").\n *\n * Example:\n * ```\n * dayOfWeek(DayOfWeekNames.ENGLISH_FULL)\n * ```\n */"} {"signature":"public fun date ( format : DateTimeFormat < LocalDate > )","body":"public fun date ( format : DateTimeFormat < LocalDate > )","docstring":"/**\n * An existing [DateTimeFormat] for the date part.\n *\n * Example:\n * ```\n * date(LocalDate.Formats.ISO)\n * ```\n */"} {"signature":"public fun hour ( padding : Padding = Padding . ZERO )","body":"public fun hour ( padding : Padding = Padding . ZERO )","docstring":"/**\n * The hour of the day, from 0 to 23.\n *\n * By default, it's zero-padded to two digits, but this can be changed with [padding].\n */"} {"signature":"public fun amPmHour ( padding : Padding = Padding . ZERO )","body":"public fun amPmHour ( padding : Padding = Padding . ZERO )","docstring":"/**\n * The hour of the day in the 12-hour clock:\n *\n * * Midnight is 12,\n * * Hours 1-11 are 1-11,\n * * Noon is 12,\n * * Hours 13-23 are 1-11.\n *\n * To disambiguate between the first and the second halves of the day, [amPmMarker] should be used.\n *\n * By default, it's zero-padded to two digits, but this can be changed with [padding].\n *\n * @see [amPmMarker]\n */"} {"signature":"public fun amPmMarker ( am : String , pm : String )","body":"public fun amPmMarker ( am : String , pm : String )","docstring":"/**\n * The AM/PM marker, using the specified strings.\n *\n * [am] is used for the AM marker (0-11 hours), [pm] is used for the PM marker (12-23 hours).\n *\n * @see [amPmHour]\n */"} {"signature":"public fun minute ( padding : Padding = Padding . ZERO )","body":"public fun minute ( padding : Padding = Padding . ZERO )","docstring":"/**\n * The minute of hour.\n *\n * By default, it's zero-padded to two digits, but this can be changed with [padding].\n */"} {"signature":"public fun second ( padding : Padding = Padding . ZERO )","body":"public fun second ( padding : Padding = Padding . ZERO )","docstring":"/**\n * The second of minute.\n *\n * By default, it's zero-padded to two digits, but this can be changed with [padding].\n *\n * This field has the default value of 0. If you want to omit it, use [optional].\n */"} {"signature":"public fun secondFraction ( minLength : Int = , maxLength : Int = )","body":"public fun secondFraction ( minLength : Int = , maxLength : Int = )","docstring":"/**\n * The fractional part of the second without the leading dot.\n *\n * When formatting, the decimal fraction will be rounded to fit in the specified [maxLength] and will add\n * trailing zeroes to the specified [minLength].\n * Rounding is performed using the round-toward-zero rounding mode.\n *\n * When parsing, the parser will require that the fraction is at least [minLength] and at most [maxLength]\n * digits long.\n *\n * This field has the default value of 0. If you want to omit it, use [optional].\n *\n * See also the [secondFraction] overload that accepts just one parameter, the exact length of the fractional\n * part.\n *\n * @throws IllegalArgumentException if [minLength] is greater than [maxLength] or if either is not in the range 1..9.\n */"} {"signature":"public fun secondFraction ( fixedLength : Int )","body":"{ secondFraction ( fixedLength , fixedLength ) }","docstring":"/**\n * The fractional part of the second without the leading dot.\n *\n * When formatting, the decimal fraction will add trailing zeroes or be rounded as necessary to always output\n * exactly the number of digits specified in [fixedLength].\n * Rounding is performed using the round-toward-zero rounding mode.\n *\n * When parsing, exactly [fixedLength] digits will be consumed.\n *\n * This field has the default value of 0. If you want to omit it, use [optional].\n *\n * See also the [secondFraction] overload that accepts two parameters, the minimum and maximum length of the\n * fractional part.\n *\n * @throws IllegalArgumentException if [fixedLength] is not in the range 1..9.\n *\n * @see secondFraction that accepts two parameters.\n */"} {"signature":"public fun time ( format : DateTimeFormat < LocalTime > )","body":"public fun time ( format : DateTimeFormat < LocalTime > )","docstring":"/**\n * An existing [DateTimeFormat] for the time part.\n *\n * Example:\n * ```\n * time(LocalTime.Formats.ISO)\n * ```\n */"} {"signature":"public fun dateTime ( format : DateTimeFormat < LocalDateTime > )","body":"public fun dateTime ( format : DateTimeFormat < LocalDateTime > )","docstring":"/**\n * An existing [DateTimeFormat] for the date-time part.\n *\n * Example:\n * ```\n * dateTime(LocalDateTime.Formats.ISO)\n * ```\n */"} {"signature":"public fun offsetHours ( padding : Padding = Padding . ZERO )","body":"public fun offsetHours ( padding : Padding = Padding . ZERO )","docstring":"/**\n * The total number of hours in the UTC offset, including the sign.\n *\n * By default, it's zero-padded to two digits, but this can be changed with [padding].\n *\n * This field has the default value of 0. If you want to omit it, use [optional].\n */"} {"signature":"public fun offsetMinutesOfHour ( padding : Padding = Padding . ZERO )","body":"public fun offsetMinutesOfHour ( padding : Padding = Padding . ZERO )","docstring":"/**\n * The minute-of-hour of the UTC offset.\n *\n * By default, it's zero-padded to two digits, but this can be changed with [padding].\n *\n * This field has the default value of 0. If you want to omit it, use [optional].\n */"} {"signature":"public fun offsetSecondsOfMinute ( padding : Padding = Padding . ZERO )","body":"public fun offsetSecondsOfMinute ( padding : Padding = Padding . ZERO )","docstring":"/**\n * The second-of-minute of the UTC offset.\n *\n * By default, it's zero-padded to two digits, but this can be changed with [padding].\n *\n * This field has the default value of 0. If you want to omit it, use [optional].\n */"} {"signature":"public fun offset ( format : DateTimeFormat < UtcOffset > )","body":"public fun offset ( format : DateTimeFormat < UtcOffset > )","docstring":"/**\n * An existing [DateTimeFormat] for the UTC offset part.\n *\n * Example:\n * ```\n * offset(UtcOffset.Formats.FOUR_DIGITS)\n * ```\n */"} {"signature":"public fun timeZoneId ( )","body":"public fun timeZoneId ( )","docstring":"/**\n * The IANA time zone identifier, for example, \"Europe/Berlin\".\n *\n * When formatting, the timezone identifier is supplied as is, without any validation.\n * On parsing, [TimeZone.availableZoneIds] is used to validate the identifier.\n */"} {"signature":"public fun dateTimeComponents ( format : DateTimeFormat < DateTimeComponents > )","body":"public fun dateTimeComponents ( format : DateTimeFormat < DateTimeComponents > )","docstring":"/**\n * An existing [DateTimeFormat].\n *\n * Example:\n * ```\n * dateTimeComponents(DateTimeComponents.Formats.RFC_1123)\n * ```\n */"} {"signature":"internal fun DateTimeFormatBuilder . WithTime . secondFractionInternal ( minLength : Int , maxLength : Int , grouping : List < Int > )","body":"{ @ Suppress ( \"\" ) when ( this ) { is AbstractWithTimeBuilder -> addFormatStructureForTime ( BasicFormatStructure ( FractionalSecondDirective ( minLength , maxLength , grouping ) ) ) } }","docstring":"/**\n * The fractional part of the second without the leading dot.\n *\n * When formatting, the decimal fraction will round the number to fit in the specified [maxLength] and will add\n * trailing zeroes to the specified [minLength].\n *\n * Additionally, [grouping] is a list, where the i'th (1-based) element specifies how many trailing zeros to add during\n * formatting when the number would have i digits.\n *\n * When parsing, the parser will require that the fraction is at least [minLength] and at most [maxLength]\n * digits long.\n *\n * This field has the default value of 0. If you want to omit it, use [optional].\n *\n * @throws IllegalArgumentException if [minLength] is greater than [maxLength] or if either is not in the range 1..9.\n */"} {"signature":"@ Suppress ( \"\" ) public fun < T : DateTimeFormatBuilder > T . alternativeParsing ( vararg alternativeFormats : T . ( ) -> Unit , primaryFormat : T . ( ) -> Unit ) : Unit","body":"= when ( this ) { is AbstractDateTimeFormatBuilder < * , * > -> appendAlternativeParsingImpl ( * alternativeFormats as Array < out AbstractDateTimeFormatBuilder < * , * > . ( ) -> Unit > , mainFormat = primaryFormat as ( AbstractDateTimeFormatBuilder < * , * > . ( ) -> Unit ) ) else -> throw IllegalStateException ( \"\" ) }","docstring":"/**\n * A format along with other ways to parse the same portion of the value.\n *\n * When parsing, first, [primaryFormat] is used; if parsing the whole string fails using that, the formats\n * from [alternativeFormats] are tried in order.\n *\n * When formatting, the [primaryFormat] is used to format the value, and [alternativeFormats] are ignored.\n *\n * Example:\n * ```\n * alternativeParsing(\n * { dayOfMonth(); char('-'); monthNumber() },\n * { monthNumber(); char(' '); dayOfMonth() },\n * ) { monthNumber(); char('/'); dayOfMonth() }\n * ```\n *\n * This will always format a date as `MM/DD`, but will also accept `DD-MM` and `MM DD`.\n */"} {"signature":"@ Suppress ( \"\" ) public fun < T : DateTimeFormatBuilder > T . optional ( ifZero : String = \"\" , format : T . ( ) -> Unit ) : Unit","body":"= when ( this ) { is AbstractDateTimeFormatBuilder < * , * > -> appendOptionalImpl ( onZero = ifZero , format as ( AbstractDateTimeFormatBuilder < * , * > . ( ) -> Unit ) ) else -> throw IllegalStateException ( \"\" ) }","docstring":"/**\n * An optional section.\n *\n * When formatting, the section is formatted if the value of any field in the block is not equal to the default value.\n * Only [optional] calls where all the fields have default values are permitted.\n *\n * Example:\n * ```\n * offsetHours(); char(':'); offsetMinutesOfHour()\n * optional { char(':'); offsetSecondsOfMinute() }\n * ```\n *\n * Here, because seconds have the default value of zero, they are formatted only if they are not equal to zero, so the\n * UTC offset `+18:30:00` gets formatted as `\"+18:30\"`, but `+18:30:01` becomes `\"+18:30:01\"`.\n *\n * When parsing, either [format] or, if that fails, the literal [ifZero] are parsed. If the [ifZero] string is parsed,\n * the values in [format] get assigned their default values.\n *\n * [ifZero] defines the string that is used if values are the default ones.\n *\n * @throws IllegalArgumentException if not all fields used in [format] have a default value.\n */"} {"signature":"public fun DateTimeFormatBuilder . char ( value : Char ) : Unit","body":"= chars ( value . toString ( ) )","docstring":"/**\n * A literal character.\n *\n * This is a shorthand for `chars(value.toString())`.\n */"} {"signature":"private fun < T : DoubleColonLHS > tryResolveLHS ( doubleColonExpression : FirCallableReferenceAccess , criterion : ( FirCallableReferenceAccess ) -> Boolean , resolve : ( FirExpression ) -> T ? ) : T ?","body":"{ val expression = doubleColonExpression . explicitReceiver ? : return null if ( ! criterion ( doubleColonExpression ) ) return null return resolve ( expression ) }","docstring":"/**\n * Returns null if the LHS is definitely not an expression. Returns a non-null result if a resolution was attempted and led to\n * either a successful result or not.\n */"} {"signature":"fun getElement ( element : @ UnsafeVariance E ) : E ?","body":"fun getElement ( element : @ UnsafeVariance E ) : E ?","docstring":"/**\n * Searches for the specified element in this set.\n *\n * @return the element from the set equal to [element], or `null` if no such element found.\n */"} {"signature":"protected abstract fun applyImpl ( data : FloatArray , shape : TensorShape ) : FloatArray","body":"protected abstract fun applyImpl ( data : FloatArray , shape : TensorShape ) : FloatArray","docstring":"/**\n * Actual implementation of the [Operation] that should be applied to the [data].\n */"} {"signature":"@ ExperimentalSerializationApi public fun decodeStringChunked ( consumeChunk : ( chunk : String ) -> Unit )","body":"@ ExperimentalSerializationApi public fun decodeStringChunked ( consumeChunk : ( chunk : String ) -> Unit )","docstring":"/**\n * Method allows decoding a string value by fixed-size chunks.\n * Usable for handling very large strings that may not fit in memory.\n * Chunk size is guaranteed to not exceed 16384 chars (but it may be smaller than that).\n * Feeds string chunks to the provided consumer.\n *\n * @param consumeChunk - lambda function to handle string chunks\n *\n * Example usage:\n * ```\n * @Serializable(with = LargeStringSerializer::class)\n * data class LargeStringData(val largeString: String)\n *\n * @Serializable\n * data class ClassWithLargeStringDataField(val largeStringField: LargeStringData)\n *\n * object LargeStringSerializer : KSerializer {\n * override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor(\"LargeStringContent\", PrimitiveKind.STRING)\n *\n * override fun deserialize(decoder: Decoder): LargeStringData {\n * require(decoder is ChunkedDecoder) { \"Only chunked decoder supported\" }\n *\n * val tmpFile = createTempFile()\n * val writer = FileWriter(tmpFile.toFile()).use {\n * decoder.decodeStringChunked { chunk ->\n * writer.append(chunk)\n * }\n * }\n * return LargeStringData(\"file://${tmpFile.absolutePathString()}\")\n * }\n * }\n * ```\n *\n * In this sample, we need to be able to handle a huge string coming from json. Instead of storing it in memory,\n * we offload it into a file and return the file name instead\n */"} {"signature":"internal fun DClass . classlikesInJava ( ) : List < DClasslike >","body":"{ val classlikes = classlikes . filter { it . name != companion ? . name } . map { it . asJava ( ) } val companionAsJava = companion ? . companionAsJava ( ) return if ( companionAsJava != null ) classlikes . plus ( companionAsJava ) else classlikes }","docstring":"/**\n * Companion objects requires some custom logic for rendering as Java.\n * They are excluded from usual classlikes rendering and added after.\n */"} {"signature":"internal fun DObject . asJava ( excludedProps : List < DProperty > = emptyList ( ) , excludedFunctions : List < DFunction > = emptyList ( ) ) : DObject","body":"= copy ( functions = functions . plus ( properties . filterNot { it in excludedProps } . filter { ! it . isJvmField && ! it . isConst && ! it . isLateInit && ! it . hasJvmSynthetic ( ) } . flatMap { listOf ( it . getter , it . setter ) } ) . filterNotNull ( ) . filterNot { it in excludedFunctions } . filterNot { it . hasJvmSynthetic ( ) } . flatMap { it . asJava ( dri . classNames ? : name . orEmpty ( ) ) } , properties = properties . filterNot { it . hasJvmSynthetic ( ) } . filterNot { it in excludedProps } . map { it . asJava ( isFromObjectOrCompanion = true ) } + DProperty ( name = OBJECT_INSTANCE_NAME , modifier = sourceSets . associateWith { JavaModifier . Final } , dri = dri . copy ( callable = Callable ( OBJECT_INSTANCE_NAME , null , emptyList ( ) ) ) , documentation = emptyMap ( ) , sources = emptyMap ( ) , visibility = sourceSets . associateWith { JavaVisibility . Public } , type = GenericTypeConstructor ( dri , emptyList ( ) ) , setter = null , getter = null , sourceSets = sourceSets , receiver = null , generics = emptyList ( ) , expectPresentInSet = expectPresentInSet , isExpectActual = false , extra = PropertyContainer . withAll ( sourceSets . map { mapOf ( it to setOf ( ExtraModifiers . JavaOnlyModifiers . Static ) ) . toAdditionalModifiers ( ) } ) ) , classlikes = classlikes . map { it . asJava ( ) } , supertypes = supertypes . mapValues { it . value . map { it . asJava ( ) } } )","docstring":"/**\n * Parameters [excludedProps] and [excludedFunctions] used for rendering companion objects\n * where some members (that lifted to outer class) are not rendered\n */"} {"signature":"public fun recursivePrintGroupInHDF5File ( hdfFile : HdfFile , group : Group )","body":"{ for ( node in group ) { println ( \"\" + node . name ) for ( ( key , value ) in node . attributes ) { println ( \"\" ) if ( value . isScalar ) { println ( \"\" + value . data . toString ( ) ) } else if ( value . data is Array < * > ) { for ( i in until value . size . toInt ( ) ) println ( \"\" + ( value . data as Array < * > ) [ i ] . toString ( ) ) } } if ( node is Group ) { recursivePrintGroupInHDF5File ( hdfFile , node ) } else { println ( \"\" + node . path ) val dataset = hdfFile . getDatasetByPath ( node . path ) val dims = arrayOf ( dataset . dimensions ) println ( \"\" + dims . contentDeepToString ( ) ) } } }","docstring":"/**\n * Helper function to print out file in hdf5 format for debugging purposes.\n */"} {"signature":"public fun encodeJsonElement ( element : JsonElement )","body":"public fun encodeJsonElement ( element : JsonElement )","docstring":"/**\n * Appends the given JSON [element] to the current output.\n * This method is allowed to invoke only as the part of the whole serialization process of the class,\n * calling this method after invoking [beginStructure] or any `encode*` method will lead to unspecified behaviour\n * and may produce an invalid JSON result.\n * For example:\n * ```\n * class Holder(val value: Int, val list: List())\n *\n * // Holder serialize method\n * fun serialize(encoder: Encoder, value: Holder) {\n * // Completely okay, the whole Holder object is read\n * val jsonObject = JsonObject(...) // build a JsonObject from Holder\n * (encoder as JsonEncoder).encodeJsonElement(jsonObject) // Write it\n * }\n *\n * // Incorrect Holder serialize method\n * fun serialize(encoder: Encoder, value: Holder) {\n * val composite = encoder.beginStructure(descriptor)\n * composite.encodeSerializableElement(descriptor, 0, Int.serializer(), value.value)\n * val array = JsonArray(value.list)\n * // Incorrect, encoder is already in an intermediate state after encodeSerializableElement\n * (composite as JsonEncoder).encodeJsonElement(array)\n * composite.endStructure(descriptor)\n * // ...\n * }\n * ```\n */"} {"signature":"@ Test @ TodoAnalysisApi fun `test - stringBuilder` ( )","body":"{ doTest ( dependenciesDir . resolve ( \"\" ) ) }","docstring":"/**\n * - Missing implementation of mangling\n */"} {"signature":"@ Test fun `test - exportedAndNotExportedDependency` ( )","body":"{ doTest ( dependenciesDir . resolve ( \"\" ) , configuration = HeaderGenerator . Configuration ( frameworkName = \"\" , withObjCBaseDeclarationStubs = true , dependencies = listOf ( testLibraryAKlibFile , testLibraryBKlibFile ) , exportedDependencies = setOf ( testLibraryAKlibFile ) ) ) }","docstring":"/**\n * https://youtrack.jetbrains.com/issue/KT-65327/Support-reading-klib-contents-in-Analysis-API\n * Requires being able to use AA to iterate over symbols to 'export' the dependency\n */"} {"signature":"private fun fullMergeControlFlowEdge ( dest : Int , frame : F , canReuse : Boolean = false )","body":"{ val oldFrame = frames [ dest ] val changes = when { canReuse && ! isMergeNode [ dest ] -> { frames [ dest ] = frame true } oldFrame == null -> { frames [ dest ] = newFrame ( frame . locals , frame . maxStackSize ) . apply { init ( frame ) } true } ! isMergeNode [ dest ] -> { oldFrame . init ( frame ) true } else -> try { oldFrame . merge ( frame , interpreter ) } catch ( e : AnalyzerException ) { throw AnalyzerException ( null , \"\" ) } } updateQueue ( changes , dest ) }","docstring":"/**\n * Updates frame at the index [dest] with its old value if provided and previous control flow node frame [frame].\n * Reuses old frame when possible and when [canReuse] is true.\n * If updated, adds the frame to the queue\n */"} {"signature":"private fun FirSimpleFunction . isPlatformOverriddenFunction ( session : FirSession , baseDeclaration : FirSimpleFunction ) : Boolean ?","body":"{ if ( this . name != baseDeclaration . name ) { return null } val superInfo = baseDeclaration . symbol . decodeObjCMethodAnnotation ( session ) ? : return null val subInfo = symbol . decodeObjCMethodAnnotation ( session ) return if ( subInfo != null ) { superInfo . selector == subInfo . selector } else { if ( ! parameterNamesMatch ( this , baseDeclaration ) ) false else null } }","docstring":"/**\n * mimics ObjCOverridabilityCondition.isOverridable\n */"} {"signature":"private fun parameterNamesMatch ( first : FirSimpleFunction , second : FirSimpleFunction ) : Boolean","body":"{ if ( first . valueParameters . size != second . valueParameters . size ) { return false } first . valueParameters . forEachIndexed { index , parameter -> if ( index > && parameter . name != second . valueParameters [ index ] . name ) { return false } } return true }","docstring":"/**\n * mimics ObjCInteropKt.parameterNamesMatch\n */"}